{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Paddle Quantum 入门手册\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Overview\">总览</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这是一份简洁、实用的关于量子机器学习（Quantum Machine Learnig，QML）的介绍，面向读者包括但不限于物理、数学和计算机背景。本手册主要采用 Jupyter Notebook 的交互形式 (调用 Numpy, Matplotlib 等 Python 包以及飞桨 Paddlepaddle 深度学习框架来实现基于线性代数的量子运算和机器学习优化问题)。我们不仅提供了关于量子计算的一些基础教程，同时还能手把手带你完成属于你自己的第一份量子机器学习算法。这并不是一份关于量子计算的百科全书，但我们涉及的案例经常出现在教科书中以及文献中。如果你想深入挖掘一些相关的基础知识，我们也提供了一些外部链接方便用户自己学习。\n",
    "\n",
    "量子计算是由量子力学与计算理论交叉形成的新型学科，本质上是通过量子力学的基本规律去操控信息单元量子比特（quantum bit, qubit）的新型计算模式。与经典计算模型相比，在许多特定的信息处理任务上量子计算被普遍认为具有更强大的信息处理优势。关于量子计算的介绍与入门知识可以参考 [1-2]，想要系统性地学习量子计算学科的读者请参阅 Nielsen & Chuang 编写的经典教材 [3]。近期，量子计算领域中一个热门的课题是如何有效地结合量子计算和人工智能两者的潜能。量子机器学习便是这样一门结合了量子计算与机器学习的交叉学科，一方面研究者们希望利用量子计算的信息处理优势去促进人工智能的发展，另一方面也存在可能性去利用现有的人工智能的技术突破量子计算的研发瓶颈。关于量子机器学习的入门资料可以参考 [4-6]。\n",
    "\n",
    "内容上，这份快速入门包括以下几个方面：\n",
    "\n",
    "- 量子计算和量子神经网络的基础知识介绍\n",
    "- 量桨（Paddle Quantum）的使用介绍\n",
    "- 飞桨（PaddlePaddle）优化器的使用教程\n",
    "- 具体的量子机器学习案例—— 变分量子本征求解器（VQE）\n",
    "\n",
    "最后修改于: 2021年8月16日 由量桨 Paddle Quantum 开发小组共同完成。\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Contents\">目录</a> \n",
    "\n",
    "<ul>\n",
    "    <li><a href=\"#Overview\">入门手册总览</a>\n",
    "    <li><a href=\"#Paddle\">安装</a>:\n",
    "         [<a href=\"#conda\">Conda 与环境配置</a>]\n",
    "        [<a href=\"#pq\">安装 Paddle Quantum包</a>]\n",
    "    <li><a href=\"#QC\">量子计算基础</a>:\n",
    "         [<a href=\"#qubit\">量子比特</a>]\n",
    "         [<a href=\"#gate\">量子门</a>]\n",
    "         [<a href=\"#measure\">测量</a>]\n",
    "         [<a href=\"#ex1\">示例和练习</a>]\n",
    "    <li><a href=\"#VA\">量子电路模板的搭建</a>: \n",
    "         [<a href=\"#QNN\">量子神经网络QNN</a>]\n",
    "         [<a href=\"#Ansatz\">内置电路模板</a>]\n",
    "    <li><a href=\"#Mode\">量桨的运算模式</a>: \n",
    "         [<a href=\"#vec\">波函数向量模式</a>]\n",
    "         [<a href=\"#density\">密度矩阵模式</a>]\n",
    "         [<a href=\"#Bell\">练习：贝尔态</a>]\n",
    "    <li><a href=\"#Op\">飞桨优化器的使用</a>: \n",
    "         [<a href=\"#GD\">简单案例</a>]\n",
    "         [<a href=\"#ex2\">应用与练习</a>]\n",
    "    <li><a href=\"#demo\">量子机器学习案例</a>: \n",
    "         [<a href=\"#VQE\">无监督学习 - VQE</a>]\n",
    "    <li><a href=\"#References\">参考文献</a> \n",
    "        \n",
    "</ul>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Paddle\">安装教程</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"conda\">Conda 与 Python 环境安装</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们推荐使用 [Anaconda](https://www.anaconda.com/download) 作为 Python3 的开发环境，支持多种主流操作系统（Windows, MacOS, 以及 Linux）。Anaconda 本身提供 Scipy, Numpy, Matplotlib 等科学计算、作图包，最主要的是其自带 Python 开发环境的管理器 conda，可以用来安装或者更新主流 Python 包。这里我们提供一个例子来学习使用 conda 创建和管理环境：\n",
    "\n",
    "1. 首先进入命令行 (Terminal) 界面：Windows 用户可以通过 `Anaconda Prompt`/ Mac用户可以使用组合键 `command⌘ + 空格` 再输入 `Terminal`。\n",
    "1. 进入 Terminal 后输入 `conda create --name paddle_quantum_env python=3.7` 创建名为 `paddle_quantum_env` 的 Python3.7 环境。\n",
    "1. 在 Terminal 内通过 `conda env list` 查看已有的环境，然后通过 `conda activate paddle_quantum_env ` 进入我们刚建立的环境。\n",
    "1. 为了能正确运行 Jupyter Notebook 我们还需要安装 `conda install jupyter notebook` 或者 `pip install jupyter notebook`。安装完成之后，如果你想开启 Jupyter 只需要在Terminal内激活正确的环境然后输入 `jupyter notebook` 即可。\n",
    "\n",
    "\n",
    "关于 conda 更多的本地指令请参考 [官方教程](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)。\n",
    "<span class=\"blue\"> 此外，你也可以通过使用 <a href=\"https://docs.anaconda.com/anaconda/navigator/\"> Anaconda Navigator</a> 开启 jupyter notebook。\n",
    "\n",
    "以下是这个教程中你需要使用的包:\n",
    "<ul>\n",
    "    <li>Numpy\n",
    "    <li>Paddlepaddle 2.1.1+\n",
    "    <li>Paddle Quantum 2.0.0+\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"pq\">安装 Paddle 和 Paddle Quantum</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接着我们安装 Paddle Quantum 包，用户可以直接通过 `pip install paddle-quantum` 完成安装。关于本地安装方式，用户可以通过 Terminal 界面使用 git指令 `git clone http://github.com/PaddlePaddle/quantum` 或者直接下载 `zip` 压缩包，然后找到对应本地文件的路径输入 `cd quantum` 和 `pip install -e .` 完成安装。接着在 Terminal 界面输入`pip list`查看是否在正确的环境中安装完成。关于 git的使用和安装，请参考这篇 [教程](https://git-scm.com/book/zh/v2/%E8%B5%B7%E6%AD%A5-%E5%AE%89%E8%A3%85-Git)。此外，如果你需要更多的关于安装 Paddle Quantum 的帮助，可以参考我们的 [Github链接](https://github.com/PaddlePaddle/Quantum) 或者通过 Github Issues联系我们。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:18:51.118039Z",
     "start_time": "2021-04-30T09:18:47.681144Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "from paddle import matmul, transpose, trace\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "from paddle_quantum.utils import dagger, random_pauli_str_generator, pauli_str_to_matrix\n",
    "from paddle_quantum.utils import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n",
    "from paddle_quantum.state import vec, vec_random, density_op, density_op_random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上的几个代码块没有任何报错的话，恭喜你！接着就可以顺利运行全部的教程了！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"QC\">量子计算基础</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量子计算（Quantum Computing, QC）是利用量子物理中特有的现象（量子叠加态、量子相干性和量子纠缠等）来设计相应的量子算法以解决 （物理、化学、计算机等领域）特定的任务。现有的量子计算有存在几种模型，例如基于绝热定理的绝热量子计算模型（Adiabatic Quantum Computation, AQC）以及基于测量的量子计算模型（Measurement-Based Quantum Computation, MBQC）等等。在本介绍中，我们主要讨论目前影响力最大、使用最广泛的量子电路（Quantum Circuit）模型。在量子电路的框架下，运算最基本的组成单元是量子比特（qubit）。这与经典计算机中比特（bit）的概念很相似。经典比特只能处于0和1两种状态中的某一种（物理图景上可以对应晶体管的高低电位）。与之不同的是，量子比特不仅可以处于两个状态 $|0\\rangle$ 还有 $|1\\rangle$ 还可以处于两者的叠加态（稍后我们来具体讲解下这一概念）。在量子电路模型中，我们通过由一系列量子逻辑门构成的量子电路来操控这些量子比特的状态从而完成计算任务。逻辑门运算的基本理论是线性代数，在此我们假定读者已经具备一定的线性代数基础。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"qubit\">什么是量子比特？</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 数学表示\n",
    "\n",
    "在量子力学中，一个二能级系统微观粒子（qubit）的量子态（quantum state）可以表示为由两个正规正交基线性组合得到的向量，这些基向量一般可以写为\n",
    "\n",
    "$$\n",
    "|0\\rangle := \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}, \\quad |1\\rangle := \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}.\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "这里向量的表示方法采用了量子物理上传统的狄拉克表示（bra-ket）。这两个单位正交向量 $\\{|0\\rangle, |1\\rangle \\}$ 一般被称为**计算基**（computational basis）。物理图景中我们可以认为 $|0\\rangle$ 和 $|1\\rangle$ 分别对应一个原子的能量基态和激发态或者其他一些二分类状态。 一个量子比特所有可能的态可以看作是二维希尔伯特空间中所有的归一化向量，这个希尔伯特空间的一组正规正交基正是 $\\{|0\\rangle, |1\\rangle \\}$。更多的量子比特系统也同样可以由高维度的希尔伯特空间中的的单位向量表示，而这个高维希尔伯特空间的正交基就是 $\\{|0\\rangle, |1\\rangle \\}$ 的张量积。比如说，一个两量子比特（2-qubit）系统可以被一个4维的希尔伯特空间里的单位复数向量表示，而这个希尔伯特空间的正规正交基是\n",
    "\n",
    "$$\n",
    "\\left\\{\n",
    "|00\\rangle = |0\\rangle\\otimes |0\\rangle := \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}, \\quad \n",
    "|01\\rangle = |0\\rangle\\otimes |1\\rangle := \\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix}, \\quad\n",
    "|10\\rangle = |1\\rangle\\otimes |0\\rangle := \\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix}, \\quad\n",
    "|11\\rangle = |1\\rangle\\otimes |0\\rangle := \\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}\n",
    "\\right\\}.\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "我们默认最左边的位置代表第一个量子比特，依此类推。其中符号 $\\otimes$ 是张量积运算。其工作原理大概如下：给定两个矩阵 $A_{m\\times n}$ 还有 $B_{p \\times q}$，那么 $A,B$ 的张量积为\n",
    "\n",
    "$$\n",
    "A \\otimes B = \n",
    "\\begin{bmatrix}\n",
    "a_{11}B & \\cdots & a_{1 n}B\\\\\n",
    "\\vdots  & \\ddots & \\vdots \\\\\n",
    "a_{m1}B & \\cdots & a_{m n}B\n",
    "\\end{bmatrix}_{(mp)\\times (nq)}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "一个单量子比特所处的任意量子态 $|\\psi\\rangle$ 可以写成基向量 $|0\\rangle$ 和 $|1\\rangle$ 的线性叠加，也就是说，它可以被描述成一个 $|0\\rangle$ 和 $|1\\rangle$ 的线性组合：\n",
    "\n",
    "$$\n",
    "|\\psi\\rangle = \\alpha |0\\rangle  + \\beta |1\\rangle\n",
    ":= \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}.\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "其中 $\\alpha$ 和 $\\beta$ 可以是**复数**，他们表示概率振幅。这意味着当我们测量这个量子比特时，根据波恩法则，测量得到量子比特处于 $|0\\rangle$ 状态的概率是 $|\\alpha|^2$；而测量得到 $|1\\rangle$ 的概率是 $|\\beta|^2$。由于概率相加等于 1，我们必须要加入如下的限制条件：$|\\alpha|^2 + |\\beta|^2 = 1$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  布洛赫球面表示\n",
    "\n",
    "布洛赫球面 (Bloch sphere) 是一个可以将单比特量子的状态 (纯态) 直观化的巧妙工具，其球面上的点表示单比特量子可能处于的量子态。（见图1）\n",
    "\n",
    "$$\n",
    "|\\psi\\rangle = \\alpha |0\\rangle  + \\beta |1\\rangle  \n",
    "= \\cos\\bigg(\\frac{\\theta}{2}\\bigg) |0\\rangle +  e^{i\\varphi}\\sin\\bigg(\\frac{\\theta}{2}\\bigg) |1\\rangle.\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "**对于经典比特，他的状态为 $|0\\rangle$ 或 $|1\\rangle$，对应着布洛赫球面的两极；对于量子比特，他的状态不仅可以为 $|0\\rangle$ 或 $|1\\rangle$，也可以是 $|0\\rangle$ 和 $|1\\rangle$ 的叠加态，所以球面上的任意一点都对应着一个量子态。** \n",
    "\n",
    "举例来说，量子态 $\\frac{1}{\\sqrt{2}}\\big(|0\\rangle + i|1\\rangle\\big)$就处于布洛赫球面赤道和 $y$-正半轴的交界处。\n",
    "\n",
    "<img src=\"figures/intro-fig-bloch.png\" width=\"400\" >\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;  \n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "**图 1.** \n",
    "单比特量子态的布洛赫球面表示。[[图片来源]](https://en.wikipedia.org/wiki/Qubit)\n",
    "\n",
    "**注意**：多个比特量子的复合系统无法用布洛赫球面来表示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例: 如何在布洛赫球面上展示自己创造的单比特量子态？\n",
    "\n",
    "我们以随机酉门的输出态为例，展示如何使用量桨内置函数绘制布洛赫球面。在这个例子中，我们使用随机的旋转角度来构造随机的酉算子，让初始化的量子线路通过这个酉算子，便可以得到量子线路的末态，这个末态就是一个随机的量子态。这样重复采样多次，生成一个量子态的列表，并采用量桨里 `utils` 包的函数将他们输入到布洛赫球面空间中，便可以实现对单比特量子态在布洛赫球面上的展示。\n",
    "\n",
    "具体代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzMAAAMzCAYAAACSq0y2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5xkVZk//s+9t3JVh+pQnfPkBMwMccgKShLMwCpiwriurmF19beG/boYdv1+XQxrYEVdwQxIWkdFEBBGmBmGyaG7q3OOlcO99/dHzb1UVVfu6lDM5/16NfRU3XDqVnX3ee45z3MEVVVBRERERERUasSVbgAREREREVEhGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSRDHttydU0iIiIiIlouQrYNODJDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERGdEU6cOIH3v//9uO+++1a6KUREVCQMZoiIaFVyu90QBAGXX355yuc9Hg/++Z//GevXr4fVakVNTQ2uu+46PP744ym3b25uxk9+8hN86UtfWsJWExHRcmIwQ0REJWd8fBw7d+7EnXfeCY/HgxtuuAGbN2/GY489hle/+tW46667Fuxjs9lw1VVX4dixYzhx4sQKtJqIiIqNwQwREZWcO+64AydOnMCrXvUqnDp1Cr/85S/x5JNP4uGHH4YoivjoRz+Kl156acF+N910EwDg/vvvX+YWExHRUmAwQ0REJeXIkSN48MEHIUkS7r77bthsNv25a6+9FrfffjsURcGdd965YN8bbrgBkiThgQceWMYWExHRUmEwQ0REJUUbVdm1axfa2toWPH/rrbcCAB566CFEIpGE52pqarBr1y7s2bMHo6OjS99YIiJaUgxmiIiopOzfvx8AsHPnzpTPa4/7fD6cPHlywfM33XQTVFXFgw8+uHSNJCKiZcFghoiISkpvby8AoLW1NeXz5eXlKC8vT9g2npY3w6lmRESlj8EMERGVFI/HAwCw2+1pt3E4HACA+fn5Bc91dHRg27ZtePzxx/VjERFRaWIwQ0REZ5ybbroJ4XAYjz766Eo3hYiIFoHBDBERlZSysjIAsZyYdLxeLwDo082SaVPUBgYGitw6IiJaTgxmiIiopLS3twMA+vv7Uz4/Pz+vTy/Ttk320EMPAQCuv/76orePiIiWD4MZIiIqKdu3bwcAvPDCCymf1x632+1Yt27dguf9fj92796N9evXY8OGDUvXUCIiWnIMZoiIqKRo1cieeeaZlKMz9957L4DYAplGo3HB87t370YgENCPQ0REpYvBDBERlZTNmzfjxhtvhCzLePe7341AIKA/99hjj+Gee+6BKIr4zGc+k3J/rSQzgxkiotJnWOkGEBER5ev73/8+jhw5gj/+8Y/o6urCJZdcgvHxcTz55JNQVRXf/OY3sW3btgX7ybKMhx9+GA0NDTj//PNXoOVERFRMHJkhIqKS43K58MILL+DTn/40HA4HHnzwQbz00kt4zWtegz/+8Y/4yEc+knK/p556ClNTU3jd614HQRCWudVERFRsHJkhIqKSVF5ejjvvvBN33nlnzvtwihkR0SsLR2aIiOiM8eCDD6K8vBxXXnnlSjeFiIiKgMEMERGdEV588UW43W5cc801MJlMK90cIiIqAk4zIyKiM8LZZ58NVVVXuhlERFREHJkhIiIiIqKSxJEZIiJalSorK/H5z38e7e3tK90UIiJapYQ8htw5Nk9ERERERMslaw19TjMjIiIiIqKSxGCGiIiIiIhKEoMZIiIiIiIqSQxmiIiIiIioJDGYISIiIiKiksRghoiIiIiIShKDGSIiIiIiKkkMZoiIiIiIqCQxmCEiIiIiopLEYIaIiIiIiEoSgxkiIiIiIipJDGaIiIiIiKgkMZghIiIiIqKSxGCGiIiIiIhKEoMZIiIiIiIqSQxmiIiIiIioJDGYISIiIiKiksRghoiIiIiIShKDGSIiIiIiKkkMZoiIiIiIqCQxmCEiIiIiopLEYIaIiIiIiEoSgxkiIiIiIipJDGaIiIiIiKgkMZghIiIiIqKSxGCGiIiIiIhKEoMZIiIiIiIqSQxmiIiIiIioJDGYISIiIiKiksRghoiIiIiIShKDGSIiIiIiKkkMZoiIiIiIqCQxmCEiIiIiopLEYIaIiIiIiEoSgxkiIiIiIipJDGaIiGhVCIfDkGV5pZtBREQlhMEMERGtChdffDE+9rGPrXQziIiohDCYISKiVcFkMuGxxx5b6WYQEVEJYTBDREQrzuPxoKGhAfPz8yvdFCIiKiEMZoiIaMUdOHAA27dvhyAICAaDK90cIiIqEQxmiIhoxe3duxfbt2+H0+nE3/72t5VuDhERlQgGM0REtOL27duH7du3o6qqCk899dRKN4eIiEoEgxkiIlpxk5OTqK2tRWVlJZ5//vmVbg4REZUIBjNERLSi/H4/LBYLAECSJEQiEa43Q0REOWEwQ0REK+qll17CWWedpf/7rLPOwoEDB1awRUREVCoYzBAR0Yrat28fduzYof/7kksuYd4MERHlhMEMERGtKK2Smeaiiy7CX//61xVsERERlQoGM0REtKJGR0fR0NCg/7uiogLz8/NQVXUFW0VERKWAwQwREa2YUCgEk8m04PG1a9fi5MmTK9AiIiIqJQxmiIhoxRw8eBBbt25d8DjzZoiIKBcMZoiIaMUkJ/9rGMwQEVEuGMwQEdGK2bdvX0Lyv6a+vh5jY2Mr0CIiIiolDGaIiGjFDAwMoLm5OeVz55xzDubn55e5RUREVEoMK90AIiI6M0UiERgMBgiCkPL5f/u3f1vmFhERUanhyAwREa2II0eOYPPmzSvdDCIiKmEMZoiIaEXs3bs3ZfI/ERFRrjjNjIiIVsRZZ52FlpaWlW4GERGVMAYzRES0IjgqQ0REi8VpZkREREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJAYzRERERERUkhjMEBERERFRSWIwQ0REREREJYnBDBERERERlSQGM0REREREVJIYzBARERERUUliMENERERERCWJwQwREREREZUkBjNERERERFSSGMwQEREREVFJYjBDREREREQlicEMERERERGVJMNKN4CIiEqTqqqQZRnRaFT/ikQi+veyLC/40vaL/3+82dlZvPTSS1BVFaIoQlVVCIIAQRAAAKIoQhRFSJKU8GUwGGAwGGAymRL+LUnS8l0QIiJadgxmiIgogaIoCAQC8Pl8CAQCkGUZgiAgFApBlmUoigJFUSAIQkJgYTAYIIoiBEGA0WjU/y1Jkv649qUFKckBjc1mQ2tra8p2qaqqf8myDFVV9bZEIhH4/X79ewD6/4GXgyCTyQSTyQSz2Qyz2Qyj0Qiz2QyDgX8OiYhKEX97ExGVOGV2CvLB5yEYTZDOvhCCxZp1H1mWEQqFEAqF9MBlcnISs7OzCIfDsNlseodfCyCMRiMsFgvq6upgMpkAIGNgkk6mkZn4bbSRGU38CE0hIy6qquqjRqFQCB6PB4qiIBwOQ5ZlPSAzm82w2WywWCywWCwwmUz6eYmIaHVhMENEVKJUVUX4vu8ifN93ASU2hQtWOywf+zKMu64GEBtlCQaDCAQC8Hq98Pv9iEajEAQBBoMBRqMRfr8fXq8XVVVVWLNmDYxGY9pz+nw+DA0NAQBcLhfsdrt+nkI6/OmCoFSPa49pwVOq65HpcUEQYDKZYDQaYbVaU26jqirC4TCCwSA8Hg8ikQgikQhEUYTZbIbVaoXD4YDFYoHZbGaQQ0S0woRc76QByHlDIiJaepEnHkHw659c8LgMYOqf7kKwuh6yLOvTqqxWq94B16ZoDQ4OwmAwoLGxMa8AIRwOY2xsDKqqoqmpKeeRknTH07z1rW/FL37xC/3fuYz4pNsm1ehOvm3SHtemtgWDQX1EKxqNwmAwwGazweFw6KM5DHCIiIom6y9UjswQEZUgVVURvP8eqIIAORqFrKqQFRWKCkQAWJ9/HNXvXhjoaB37UCiEwcFB1NfXw+FwpD1PumDAZDKhpaUFfr8fvb29cLlcKC8vz9rm5I5+8mOpno9/Ll3Qkkqq7VO1IVPwoSiKvo0kSbDb7fpolLafNoozOTmJUCgEg8EAh8OB8vJy2O32jCNdRES0OAxmiIhKgKqq8Pl8mJ+fx/z8PKLRKJyDfVCCYW0DqNDySkQIUxNpO+7hcBj9/f3o6OjI2tHONqphs9nQ2dmJwcFBzM3Nobm5WT9Pslwfy7Ut2UZ5Usm0fb6BjtYeLbdIURRIkhQLNINBTE1NYWhoCKqqwmKxoLKyUp+iRkRExcFghoholQoEApidncXMzIw+Xcxms8HlckEURfhbOgHPfkBRAAEQhNNLh4kCxJaOhClSQKxjHolE0N/fj/b29gWBTKG5KKIoorW1FTMzM+jr60Nra2vGaVvZEv/TPZ5PoJFJ/LHir81ip4fFj2JpxQM04XAYXq8XExMTiEajsFqtqKqqQnl5OSupEREtAn+DEhGtEtFoFHNzc5ienobf74fBYEBZWRnq6uogii+vcax1uk2vezsCB18ABAH6GsiqChiNML7qxgXbK4qCvr4+NDU16dXI4iVP99KS+rPlk2iqqqogSRJ6e3vR3t6+II8m1/yXVPvkGmjke45sx801nyZ5++R2aIUHKisrAcSCm5mZGQwNDUEQBJSVlaG6uhp2u505N0REeWAwQ0S0gsLhMKanpzE5OQlZlmG321FeXo7a2tqsIyKG7btg+fsvIPiTbwKeOQCxuMb8mf8H0dW4YL/h4WG4XK4FlbySj5v8fTrJwY6qqigvL4ckSXC73WhtbU0Y/cmj4EzB++QyFS3f4CjdvumqsGV7DogFN9XV1aiurgYQG4UbHBxEKBSCzWZDTU0NKioqEoJYIiJaiMEMEdEyC4VCGB8fx+TkJAwGA8rLy9HY2Kh3XOOnPsVLNUphvPx6GHZdDd/n3gu15yhUCBBSdKTn5+f1YCP+WPHHTpZtlCNdR9tut6OpqQl9fX3o6OjQR2gKyXHJtk+2NhaapxN/rePLTufT/lSBTbr2Wq1WPcgMh8OYmJiA2+2GyWSCy+VCdXU1AxsiohQYzBARLYNoNIrR0VFMTU1BEAQ4nU60t7dn7Gwnd+TTVu0ymmDcdh7C3UcAVUX06T/AsGWn/rwsyxgfH0dnZ2faYxUyapLc5vhjWCwWNDQ06AFNrqMjqdaWySRbIJPr60oOPOL/v5jcnFweS6YFMEDsczM7O4v+/n49X6qqqopT0YiITmMwQ0S0RBRFweTkJEZGRqAoCiorKzMmx2ea5pV1lKSpPVbNTBQRfeFJqOqn9f0HBwfR0NCQ9c5+8jmy5YLEf5+qbXa7HVVVVRgYGFjwunPNwylWMJE8wpJt+8XKJ5DSzp2qDLbRaERNTQ1qamoSRmwcDgcaGhqylsMmInqlYzBDRFRkHo8HQ0ND8Hq9qKioQFNTE4xGo756fSrZKnVl6xiL9c0QTq8tps5NQ+k7Bal9LYLBIADoa6PEHz/X0Zl0o0O5dNYrKysRDocxMjKChoaGvKuZZQtkcg0asgVF2nuTS+CUvJ0sywgEAvD7/QgGg/D7/QiHw4hEIgiFQlAUBbIsZ31tqqpCkiQYDAYYjUZYLBaYzWaYTCZ93Zr6+nqoqqpXpQuFQnC5XKirq0tZ1IGI6JWOwQwRURFEIhFMTExgdHQUBoMBtbW1qK+v1zvb6fJgNIWOCugjJqcT/gWoUFUg8rcnILWvxdjYGOrr6/Xtk9uTTqZRF+2cqabBpRpdcLlcGBwcxPT0NKqqqrK+lnzkE4RkO2e2YGd2dhYejwcejwfz8/MIhUL6aJXZbIbFYoHNZtPXktEqmJlMJr2Edba2yLKMSCSCQCCAYDCIaDSKYDCoV7iLRCIAoFe6q6io0Ef/rFYrGhsbUVlZuaCSHBHRKxWDGSKiAmkdTW3BSKfTiba2toSOZKopWZmk2y7T4wAgOGsgmIxQw2FAECA//yR8190KURRhNpsXtCddQBK/TaY2xrdJC2Ayvcampib09PTAbrcntCfVcfO1mNGb5GBMEAREo1FMTExgbm4OMzMzetDicDj0EsqdnZ1pq8Klkut7r43KpDu2FjwFg0HMzs7qbdRGgw4ePIiKigqsW7cOLS0tMJvNzK8holc0BjNERKepqgp1dABqJAKxqR1Cmrvb4XAYHo8HIyMjCIVCqKmpSRj9iD9eplK96dqQ6hi5BBhCXTPUwd7Yv8sqMTo0iJaOzpT7ZxqNyLdiV67BT2trK/r6+rBmzZqsx00eMVlMPkuqqmTxfD4fJicnMTExAY/HA0mS4HQ69Rwnm82Wtm3Z1qHJNCKXKaDM9FoURdGLBGiFArTnpqenMT4+jj179uD3v/89GhsbsWnTJrS3tycs4klE9ErBYIaICIB84iCC3/z/oLhPAACEmjqY7/gMjLuuBhCbRhaJRODxeDA+Po5IJIK6ujo9FyV++lY+ZXyzdYzzCSykbedBmZ0CvPNQz78SRqtNz9VJJZekeK1dqaaPZdo+VZ6NtrbK0NAQmpqa0u6rtS35sXRtzzW5X3uPQqEQRkdHMT4+Dp/PB6vVipqaGqxZs0Zf1DLX0ZzFFBRI/pwkB13ZRuNSPa6tXbNx40YoioLe3l68+OKL2LNnD8rLy9HZ2Yk1a9YsyKEiIipVQh53u4pX5oWIaBVRJkfhe9/1QDgIKMrLTwgCxC98D/K6bQgGgxgdHYWiKHC5XAvu1sc2Tz0Kk28wkLxvqqlQ6QR/+k1EfvczBC+4CuUf/peUU7qS25OpTPJSTFEaGBhAeXk5KioqFjz31re+Fb/4xS8WdfxU7Z6amtLzdrScpsbGxmWpBpbpPVzMZyNZuqIOgiBgenoao6OjCAQC8Pl8EEUR7e3tWLt2bdppf0REq0DWP0IcmSGiM17ksV8mBDKKoiAkqwirgPiL72Hqtk8hHA6jqakp41SdxY6ApNs31ffpGLo2IwJA6j+ZMTcluWxxvPgyzEuhqakJvb29sNvtMBiK/2dIu94jIyMYHh6G1+tFeXk5mpqasHXr1gWJ+IudxpZLe9L9O12p6+RtUz2erRpd/L+rqqrgdDoxPT2N6elplJeXw+v14g9/+AOsVis2bdqkF6wgIiolDGaI6Iyn9B4HFAURWUZIVhBR1ViZY0FAuPsYnE4nHA5H3sdNlzORXCksn3yJbOcR120FVBWG0QGoQT8Ey8IRpFzanUs78un4xr9OURTR2NiIwcFBtLe3F9SeVNdCURSMjo6iv78fwWAQ1dXVWLt2LSoqKhY1HSwXyblNmc6XLnhKLnudKQjO1OZ0eTjaNLSqqipMTk5ClmWcffbZAIDjx4/j+eefR3t7OzZs2MAyz0RUMhjMENEZL1pRg3lZgRqRoQoCBEGEAECBCmNtE+xpAplsIy7pApbkUZFck+hz6diKNXWQK2ogzU1B7j4Kw+YdSzJdLN/jJQdzVqsVJpMJs7Ozep5KuuNmq+42MTGBvr4+zM/Po7a2Fhs3btSnsOVbSKDQaV/55knl+nwhRRByGQWsra1FVVUVhoeHEY1GsXnzZhgMBgwMDOCxxx5DfX09Nm/eXFAQT0S0nBjMENEZKxgMIhwOI3rptVB+dx8EMRbEqIoC9XRAY7r2LWn3zzXXJFPnONdOaq4Byfz8PNSu9cD+v0I+eQSGzTuKnuCfy/GydcIFQUB9fT16enpQVlaml7NO7sina5Pf70dPTw9GR0dRWVmJjo4OVFdXL9g3WyGBVO1ayilnuch3JCaX/ZOfFwQBkiShpaUFgUAAAwMDsFqtaGlpQWtrK8bHx/Hkk0/CarVi586dy5JbRERUCAYzRHTG0YIYvfpY+zqE3vFRmO79FoRoGBBFACoEFYA1t2laqaqZAfndhS+G6elpuDacDXnfM1BOHICqvi1r5zaXQCbdyFDy68302uOvkXZel8uF4eFhtLa2Juyfal9FUTAwMIC+vj4AQHt7OzZt2rSoCnCZ5BvYFBIILVWRhWzni2+n1WpFZ2cnZmZm0N3djYaGBrhcLtTV1WFqagpPP/00bDYbdu7cyZEaIlp1GMwQ0RlBK8kbDoehKAoURYEoigiFQhgcHETlrteg7MrrEfnbEwj/1/+BqgpQoSL0g6/CsOFsCOWV+rEyJV/n2rEuRic2VeCkKApMG7YhKAiQTx3JuF+ua9hkam+q4EYjimJCAJScEwIA5eXlmJmZgdfrTSgXHN+ucDiMEydOYGxsDPX19di5cyesVqse4CSfv1gBQr7XpZA8qHT5LUslUzCq5YYNDQ1hfn4eDQ0NqKqqwkUXXYTJyUn8+c9/RlVVFc4991zm1BDRqsHSzET0iqYoih7EAIkd1MnJSczNzaG5uVmv/KWqKvyffz+Uo/v17QwXXQ3rx/5PTudLDhQKkW50Inmb5Ofn5ubg8/lQU+5A6F2vAVQZwn/8Aqiq1QM4RVH0oEeJq94Wv7ZJui9RFFP+W5IkSJIEg8GQ9jVnek3RaBS9vb1Yu3Ytbr75Zvz85z8HEBtlOnr0KMLhMLq6utDS0pJwnFTfa+cqtHpcqnYvxbSzTO1fDWZmZjAzM4OGhgZYLBa9fcPDwzh69CjWrVuHLVu2rLp2E9ErDkszE9GZSVEUfTpZPEEQEI1G9RyBzs7OBR0yw+btCB3Zd7qiGRD9625ELrwSxguuzHjO5FyRXGXLMZFlGZFIBNFoVF+8U/telmV9u6GhIdTX1yMajaK8qQ3SYA/8h/ZC3XGJHnyIopgQeEiSpD+ntUULeJK/V1UVsizr7YsPkGRZhizLC0ZKDAZDyi+j0ZjQBqfTibGxMX0q2cmTJ2G327F582Y4nc6M1cJyGTEq1FIFRdnaX4hUQV26QCxbAOV0OlFWVob+/n5UVFTo+UiNjY2or6/H8ePH8cADD2Dnzp1oaWkpSvuJiArBYIaIXlFUVUUwGEQkEtE74vGdNr/fj8HBQTQ2NqZcBV0QBEhbdkL49d2AIACnO4OhH3wV0sazIVZUpT13Lp3SdFPUgsGg/hUOhxOCFFEUEwIAi8UCo9EIo9GoByNa4LFmzRoAQHDTdkQGulE+MQBLXV3WdmVra7qOcaZOsdamSCSiv6ZIJAK/368HmVoQZDQasX//fr208nnnnYeysrKU59D+nalNxRrtyGX0JJdz5ZKTlMv1zXSudFP+Uh07W+4TEAtEOzo6MDw8jP7+fjQ3N+ujcRs3bkR7ezsOHDiAU6dO4cILL8y4BhMR0VJhMENErxjhcBiBQCDtCIk2daa9vR1GozHtcaS1WyAYjVDDYUAQoBpNUOemEPrBV2H5+FcK7iRHIhE9YAmFQohEInon02w2w2KxoLy8HBaLRa/ulU5y53N+fl7v/AOAtG4zIrt/DeXU0YLaqp0j1ffxMl2L+CloFosloWqa9n00GsXRo0f1xHOz2YzOzk5MTU3pIzWCIMBisehBnMVigclkyjiiVUh55Uyyvc5MihHsJJ8rn2AtU3CXbUqkIAhoamrC/Pw8uru70dLSogctVqsV559/PgYGBvDII49g69at6OrqWvDZVRUFEJZuEVYiOrMxmCGikheJRPQgJj4JO97w8DBkWUZnZ2fW4wkmM4S126Ae2QuIEoRIGJCMiP7tCSi9x2Ho2pix86mqKvx+P3w+H4LBIKLRKADonXotaDGZTDnfdV/QxqTtPB4Pampq9H9La7YAAOTuo1AjYQjGzAnb2XI4UuUCxY+QaEFHumlg8c8LggBZlnHkyBGMjIxgzZo1uPrqqyFJEsxmM5xOJ6xWa8I5tQAwFArB4/Ho1egMBgOsViusVivsdrs+XS7+fKkCm2yjO4VId6x8iwHksm+qx/MZtYnfJ92+8Y9pQXZ/fz8aGxths9n047a2tqKurg779u1DX1+fPqqmnjiI0I//H+SDfwOMJhguvx7md3wUYmU1iIiKhcEMEZWsaDSqBwvpOnKqqur5MY2NjQueS9fJM2zZifCRvRBq66CODkFsbof53Z9MGciEw2H4fD74/X4Eg0F9JMHhcKCqqgoGQ26/ahdz5zoUCiVM8xEaWwFHOeCdh9J/ClLXJgC5VV3LlIOSbrtMuULxHWZZlnH8+HGMjIxg7dq1uPLKKxPydaxWK0ZHR9He3p7QudeCwOQOfzQahc/ng8/nw+TkJBRFgSRJsNlssFqtsNlsGV9PtqA039ynxVjM/tkKT2SbrpZL3pHJZEJHRwfcbjdqampQUVGhH8dsNuPCCy+E2+3Gn/70J2x3OmD9+sdgEVSIABAOIfrHByAfeh72u34LwZJbyXMiomwYzBBRyZFlWc+LAdIn0CuKgr6+PlRUVKCqKjHXJVtH1bDjIiDkh9DcgdC3vghloAdiRRVkWdZHXQKBAGRZhsFggMPhQHV1dV55A4V0llNtHw6HF0ybEwQB0rrNkPf+FfKJQ3ows9RTfVK1USu6cPLkSYyMjKCzsxOvetWr9NLN8ftpBQp8Ph/sdvuC0R5te21fg8GAyspKVFRU6OfT3iO/34+pqSk9wDGbzbDZbLDZbDkFmPleq5WsSpat8ESm4BXIve2SJKGjowP9/f2IRCIJo4FAbO2fmpoazHzpIxAiEUQUBWaDCIvBACgy1OF+RP78MEzXpF+MlogoHwxmiKikBAIBfYoR8PJq5vFTzIBYIKPdQU5evTxb/oCqqpA6N0Lq3Birivb07yEc2IOJ+74P3xveA5vNBrvdjpqamqy5LfHHTfV4PtJt7/F4Ui5mKHVtgbzvWcgnDgPX5HWqhHNmGzHINgWtt7cXp06dQkdHBy6//PKEkZj4/bR96+vr0d/fj66urgXva3LOTfLzQKzDXVZWlpBDpCiKHuBMT0/rRQe07TIFN7l29EshJyTTZz9Xoiiio6MDfX19mJycXBDQOBwOKCPdEAGoooiQrCIUCcFuMsBgNEI+9ALAYIaIioTBDBGVhPjkfk26/AJVVeF2u1FbW5vQoc1GO144HMbc3By8Xi8AoPzyG2E+sAe2/U+h9r2fhFjhXHD+TJ3+YuRkZDq+1+tFU1PTgseltafzZk4dLPi8qqpC9cxCVVT9dafbLr6dgiBgeHgYx44dQ11dXcJ0Mm375NEE7RhGoxEOhwMzMzNwOp0JOS/J73+2664dWxRFOByOhKBPy78ZHByELMswm836NvHBTSkEKcmKFUCnO56qqmhtbUV/fz+mp6cXjHyKjgqoAT8gAKoAQBThjcowQECFbWHgTURUKAYzRLSqxefFANDvyGcyMDCAqqqqtIFMcodOURR4vV7Mz88jFArBaDSioqICNTU1sY50Rwf8D22E0n0Ekd2/helN79JHErROXrHWI0knU0AUjUZTjixIa07nyYwOQJmbyRiMxJ9Hex1yzzEE7/46lBMvAaoAsWsDLO/8OKQNZ+n5L9oaM/HrzUxPT+Pw4cNwOBxYu3YtTCYTJiYm9FGUVF9A7H0JBoMYHByEqqo4deoU2tvb9ee0/8cHKFqp4FTr5kiSlLCNRnvPzGYzzGazPrIQDAbh8XgwMDAAWZZhtVrhcDhQVlaW9TO3EjKNGGVK7C/0XKm0tLTA7XZDEAQ4nS9/vgznX4HIw/eeXm5bAKACgohoVEFg5+UQg0GWciaiomAwQ0SrllbGGEi84588IhK/ev3AwADsdjsqKyszHjsUCmF+fh5erxeqqurTxlJ1sARBgOn6WxH8z88hsvtXMN34NsBkBpA+oX4ppLrbHggE0nYKhbIKiI1tUIbdUE4egnTupQv2j0ajKb/kiRGUffUfgHAIgipAEFTIvcfh++IHMP33d0JtaF0QSMiyjGPHjkGWZZxzzjkJQUB88JccmMQHhWazGbW1tQCg58SUl5cvGJnRAkjtS1tXSPvSgi1tOy1oih8F0spGGwwGfS0fk8mE2tpaGAwGvUre9PQ0FEWBxWLRp6UVa4RjMRYz9S2fz222KmltbW1wu936iJoa9EM59HysHDMARVUhCCIAFeHrbkXZ+m36DQqz2ZyxTDoRUTYMZoho1dHWY9EWjsxlKpGqqpiYmIAkSfpq5cnbhcNhTE9Pw+/3w2g0ory8HG1tbQvuuqfqvBkuvBLCffVQJ8YQeeoxmF51U3FebB6SO+RA6nwZVVURjUYRDocRbVsHcbgPM/ueg7+2Ve/gawGENpKhLcJpNBphtVqBx34GJRKJLRoqAKoqQFQVqIII14tPwXbR5xLOd/LkSQwODmLLli2or68v+DWKogizORYotrS0oLe3F3V1dWmD2cVQFOXl4E2WEY1G9QBGeyz+Mzg/P4/x8XGEw2GYTCZUV1ejqqpKX/8ml3YVq+2p5HNt8gnGUo1qxRNFEW1tbejp6UFbSwvkb/5/kPtOAYgNzIidG2A8+0II512JfUNj6OjvR2trq36NDQZD2qpzRETZMJgholXF7/cjFAotKCOr/T9dh8fv98Pr9aKjoyNhu2g0iunpaczPz8NoNKK6uhoNDQ0J++ZUptZghOm1NyP0028i8tC9MF7xOginRyYydSCL2fnWjqcoCsLhMILBIAYGBmLVo2ZmIMtyQpBiMplg7tgA8dk/wDrSi6rm5pwKFgCAr/sYoEQRmyIEACpUQQDkKNQTL+fgjI2N4fDhw2hubk5I7s9Fuip02vdansvs7Kw+0lbotUz12RFFESaTCSZT5jV44o8RiUT0gGdqagoHDx5ENBqF1WpFWVkZjEbjy9febNb/r40+FPvzkNy+pZbuHJIkoaWlBdPfvRP2F57SNgZUAbaP/h+IjW0AgEs61+HZZ59FIBDA+vXrAcRy1GRZ1hdDJSLKB4MZIloVtM651iFP1dFNF8hEo1GMjIygo6MDQKzDNTMzg7m5OQCA0+lEV1fXggApWznbZMZX34jgr38IZcgNef9fYdhxcU6VvrJJ9doURdEXiQwGgwiHw4hEIno+iNFohNlshsFgQH19PYxGY8pAQj77PPjvBdTuYxDzqVhVWQ1FkABFPr16++n0B0mC4KxCKBTCvn37IAgCdu3aBbPZnDI5P5NUAWvy97W1tejp6UkIZnJ9v5Irq+Wzf6qgQxAEPfjRpiUCgBwMwPP8X+AfOYVQ23oYql36gqherxdTU1P6iJj23mlBjvaVqk2LzXdZ7lLR4hMPw/7MI4Bw+nMoANKWHZCa2hMq0F100UXYt28fjh49io0bN+oBulap0Gq15hx0ExExmCGiFaWqKgKBAEKhEICXS+8mV7jKZHBwEA0NDfD5fJidnUU0GkV5eTlaW1shSVLKTl2+nTxVVSHYHDC9+kZEHroX4UfuhWHHxXkdIxVZlhEIBBAIBPS1c7R8Dq3j7HA4UuYWaAtGatOyUhFbuwCzFQh4oQy5IbV0ptxOUZSEYMj4qhsRee5xCAIAVY1VpIptiOmtu3D86aexdetWuFwufZ9so1uFEEURZWVl+uhMPsddTDWvXAMz+W9/gf87X4Tk86AMQJlkAG74O8xd+jqETnfMa2pqYLfbE6rlaYGq1+vVS41rU+wsFgusVmvG9zUXhQZthYjuewah//4PnJ6TCBWxfBnjq163ID9HEATs2LEDe/fuxZEjR7Bp08sLukajUXg8nqK8fiI6MzCYIaIVE19uOd2aIfFleYGFd9nHx8f1O992ux319fULpqoUI1lbO4bptW9F5JFfQD74ApSeoxA7N2Y8RvwUuWAwqActWgdWW8zRarWioqIir2k2Pp8vlt+SgWgwQlqzCfKhF6CcPJg2mIlP1FdVFYZzLoT5rXcg/MvvQQVOd02B+YZ2zK8/B1ds3LhsFb5qa2vR29ubsajDUo5CpDuuMuSG/xufBqJyrA8PQJCjwP33oK61E8ZLroHf78fs7CxGR0dhsVhQVVUFq9UKk8m0YP0jbTHYYDCIqakpBINBfSQuPsgpZhWw+DysQq+hGgkj+MOvAqoMmC1AKBgLgu0VMJx3Rdr9UgU0Gu1nxG63r8pKckS0ejCYIaJlp00piUajCdNPUt0hTjXVR1VVzM3NYXJyEiMjIzjnnHNSLhoZv30hUu0nuhpguPBViD79e4QeuhfWf/jXBftoCzT6fD4Eg0G92prFYoHFYkF1dXXaqUX58Pl8qKioWHD+5OlbUtdGyIf3Qj55BMYrb8z59Zrf/B6oAS8iD92L0111lAd9aFy3FkIROpipOs8pr7kowm63Y25ubsHr1axE8njkz787XSDhdMCLWI4IRAHhR34O4yXXwGazwWazAYjldU1NTSEUCqGsrAxVVVUJJbUlSYLdbofdbk84j/bzogU52iimyWTSj699ngqdUhf//3wJRhNsn/1P+P/901AHewCrHQh4ETrnIpSZXw68UrVHC2iOHz+u59Bo2yqKAo/HowdyRESpMJghomWl5YAkl9rVcmUykWUZU1NTmJubQ3l5OcxmM84666y0gUz88YvJdP2tiDz9v4j89Y8w3vJBhOzl8Pl8CAQCkGUZoijCarXCbrejtrZ2yeb/h0IhvaOsSXUNxbVbAKiQTx7KeLxU+wZnZyCpAAQBMBqBmXFEn9kN4+XX59zOQvJckrlcLrjd7rTBzEpQRocBVTkd5iH239NLqijjQwu21wIPLRgfGBgAEMvpqqioSPvatWAuOcgJBoMJARIQC3C0z14u07SyBfu5vndqNAp1yB0L7iIhQBAROPdKBOPWk0l3nB07duDZZ5+F2+3W1xXSzg1Az6VxOBwcpSGiBRjMENGyUBRFnzqSb25FKBTC+Pg4IpEIqqqqsGbNGkSjUQwMDCyYqpOrQjtxwWAQ3koXxDVbYTh5EJO/uBvqm94Nm8224E57rucqVK4dTWntllgHu/8UVL8Pgs2edR9ZlnH48GFU9fegAgoAIZZ7E4kg/ODPYLjsurwClFzzltJdJy1x3u/3Lwjg8mlDMaejic0dwN/+fDqQOT0qc3q1e6m5a8G54/9dWVmJyspKvdpeT08PzGYzqqqqcn592khfvFQBjsVigcPhSBkMZPtc5roOTeiebwCqAuncS2C88CrIxw+gdvsFGB0dTQhQUu0rCALOP/98PPPMMzAajWhqakrYRhu19Xq9rHhGRAswmCGiJReJROD3+xeMxiRLzk/xeDyYmpqCKIqoqalJ6ORNTEwkJJ/nK9dOXCAQgMfjgd/vhyzLMJvNsNvtsNx4G6Lf+BTsLzwOx7s/CsGW2+hQwXkJSfuFw+GUgVMqYrULgqsB6vgI5FNHYNh2bsbtp6am8OKLL6KrqwvOaAiKVp3K7wOsNiiD3bFqbtt35dz+YgQQLpcLo6OjaGtry3vffBaJTLd/8lRI46tvRPjBe2I5M9qoDAAoCkyve9uCc6diMBjgcrngcrng9/sxMzODkZEROBwOVFVV5b2gZHKAo6qqXrZ8enoa0WgUFosFdrsdDodDX/C0ENpnMvrsHyAfegEwmWG5/RMQ6xphvPQaALFAJBAI6Lld6cqgC4KAiy66CE8//TTMZrNeKU7bJ/61RCKRBaNURHTmYjBDREsqGAwiFArldFdcFEXIsozp6WnMzs7CarWiqalpQYdOS5ROXi9msbTKalrwoqqxFekdDgeqq6sTpoup518Gf2MHlGE3In/6HUw33JrTORZTjCBefAcxF1LXZkQnRiCfOpw2mFFVFUePHsXU1BQuuugiWCwWeCdGTx/AAMhRGC58NaKP/w6RZx+HdM5Fy5qropV/1hatXE4pR9dECTCagYj/9EYAzBaYb/8YDDsvyTtwjZ+GNj8/j+HhYciyjKqqqozT0DIl8AuCsGCKWjAYhNfr1Y+vLVpZVlaWcmpaupFFQRCgBnwI3fNNQFVguukdEOsaE7apq6vDyMiIPjqTqQS1JEk4//zz8fTTT2PXrl2wWq0p1x8Kh8NQFAU2m40lnImIwQwRLQ1FUeDz+RCNRhMqZWmSSy8rioLJyUnMz8/D6XSivb09bUdlcnIS1dXVRWlnIBDA/Py8HrzE57pkmp8viCKM19+C4H/9G8KP/hzGa98CQUr/K7VY05u04wQCgbzuTkvrtiD63J+gnHo5bya+TV6vFy+88AIaGxtxySWXAACUuRkgHAAgxEZ2RgZg2HY+jDsvg7Rj14ok3dfW1mJiYmLBVKSVEPrxN4GAHxBj5YgBwHLHZ/RRiXyn4cX/u6KiAhUVFZBlGZOTk+ju7kZZWRlqamoW/Fzkm8Cvjd5oox+RSARerxfj4+MIhUIwm80oKytDWVmZXto8nfBvfwR1ZgJCXXPCaJRGC0Cj0WjakcT4dlssFj2H5rLLLku8gRAX1MiyzBLORASAwQwRLYFoNAqv1wsg/V3d+KkjU1NTmJ6eRk1NDdasWZP1+B6PBy6Xq6C1YhRFwfz8PDweDyKRCCwWC8rKyrIGL6kYL7sW4V/8F9TJUUSf+zOMu65Ku20h66Ok2kd7LBwOJ0zFyUZauwUAIJ88rAcx2rF6enrQ29uLnTt3JiTYq1NjAAQIFVUQG5ohjwxADfozvs6lZrfbMTIyAlmWV/SufHTfXxH96+9jC0Sqqj5yhWg052PEj6gkP6aRJAl1dXVwuVyYm5uD2+2GyWRCbW1t0Sp8GY1GOJ1OOJ1OALEctfn5eQwMDEBRFFgsFpSXl8Nutye0TRnqQ/ihewEVsLzjHyGYU7enoqICs7OzOX9eKysrsW7dOvztb3/DBRdckHE0J37a2UoE10S08hjMEFFRadPKUkkuGzszM4Pp6WlUVFRg7dq1OR0/FArpq6unk9wh9Pv9mJubQyAQgCiKcDgcKdejyZdgMsN49ZsQ/tUPEH7oZzBc9OqMU4HSlZ9ecNwcOmWZ7nSnInasByQJ6uwU1PERCHWNiEQieP7552Gz2XDFFVcsCOaEymqY3/lxQFWgjA5CBqCODeqvJ1UJ4EJKA6e7JukC4ZqaGkxOTqKuri7n11/MxH81GEDw7q8BECCu2wrl+AEIFU6o0xNQw8Gcj5MpWE043+m2O51OVFZWIhAIYHx8HLIso7q6uuAiGMnH15jNZtTW1qK2tlbPU/F4PBgfH9crq5WXl0P+0b8DcgTi9osgnXtJ2uNXVlbC7XbnHMwIgoDm5mbMz8/j6NGjC9ag0bbR/h+JRODxeGC32zntjOgMxGCGiIpC6/REM9yZ1jogs7OzmJycRHl5Obq6uvLqZGorwac7vpabMzs7i/n5eUSjUVitVpSXl6O+vr7od2+Nr3kjwg/8GMqpI5CP7odh0/a02xZS0SxVhz7bcVLmTpgtENvXQ+k+AvnkIcwYzNi/fz+2bt2aNigQq2phuvatABC7A4/T5YiRespgpu8zSbdPutdZWVmJU6dO5TU6V8z3Pfzru6GOD0OorQOMJgAChKraWDATDKTcZzHBlLZf/HpFra2tiEajmJycxPj4OCoqKlBdXb1g8dNcj5+ufYIgwOFw6FMateld03/8HRwH9kA1mCDe8uGsuXCiKOYdgG/atAlPPfUUxsfH4XK5MlbEUxQFXq+Xa9IQnYFYsJ2IFk1b3C4SiQBI3wmdn59Hd3c3gsEgOjs7C5oq5vV6U64ro+UWuN1uuN1uyLKMxsZGdHV1obGxEQ6HI6eOcrxcthErqmC87HoAKiIP/SztcRZTMSqZlteQTrpzSWs2AwAm/vYXHD58GJdccknW0Q19ypsrltitTAzn1O6lVl5ejtnZ2RU5t9jaCaGsEua3fRTKiVgOkljTFJtuFkodzCw2mIqfFqj932AwoL6+Hl1dXZAkCT09PRgeHkY4HM47cM5UJjv+WJIkocJiRtkjP43td81bMG2yobu7G4ODg/B6vSnPbbfb4fP58m7X+eefj5deegmhUCjhGiS3Ufs+GAzC5/NBUZS8zkNEpYsjM0S0KKkWwUyeUqUlF1utVrS1teV1dzaZdmwgNtVqdnYWHo8HQKyD29LSktNUk1w6l6k6TqkeM11/MyJ//C2iLzwFZagPYlNi6eBijwb5/f6C7j4rnRsAAKaBU7j0H/9PTvtobY9VqVKhjg/mfd6lUF1djb6+Pj3PI5PkYhOLZbz0Whh2XgqlvxsIByGUOSHU1gKCkHaaWXJ+TL6fCW1UJhVBEFBVVYWqqiq9ShkQK5Zgs9mKVkFPE77/J1AnRiHU1sH+lveizBIrmR4IBDA3N4exsTEYDAZUVlairKxMn9o5MzOT96KnJpMJZ511Fp5//nns2pW5FHh8tbNoNAqHw8FpZ0RnAAYzRFQwn8+3YBFM4OVORSgUwsjICAwGA1pbWxcVxACxwEkURYyPj8Pr9UKSJJSXl6O1tXVZOi3ppuEITe2Qtl8Ced9fEH7kXlju+MyStiMcDqOsrCyvfSYmJnBsxo+zAZhHB6BGwhCMuecMia4mAALU+TmoPg8Ee37nLzZJkmAwGBJWmE9nKRYsFWwORA/tjbVl0zkQTJZYMYA0IwKZpnLldL4c99MWxwyHwxgfH8fExARqa2uLti6LMjqA8EM/BaDCfNtHIVheXvvJarXq5cLD4bA+ndRoNKKiogKBQOpRq2y0CnYnTpzA+vXr9ceTr2dyCWev1wur1cpFNole4TjNjIjypk0ri0ajKe96q6qKsbExDA0Nob6+Hs3NzXkHMglVkxQFU1NTOH78OGZmZmAymdDe3o62tjY4nU49kCm005ppv1yPabrx7wBVQOTJR6HMTRfl3OmezzbNLNnJkydx5MgR7Lz2dRDKKoFoBKr7RM77A4Bgs0OorAagQhnPPNUsuYOZz/uSz7ZaJ3c5pAom5COng5ktO2B6yx1w/OJZWN7xsbT7L2e1LZPJhObmZjQ1NWFmZgZutxs+n6+g9sRvF7zn/wGRMKRt58Nw/pVpj2cymeByudDV1YX6+noEg0EMDAxgcHAwoR252rhxI0ZHRzE3N7egXZmKbvj9/oKDKCIqDQxmiCgv0WgUHo8HsiwndFS1DoXH48GpU6dgMpnQ2dlZcDKuqqrweDzo7++H2+0GADQ0NKCzsxNOp1Ofapa8PkchMu2X6zGljedAXLMJCIcQ2f3bnM+drRx0yk706YUOs5FlGc8++yz8fj8uvfRSWK1WiOs2A1ARPXkw5T6ZggnB1QCoApSxoYz7xecrZOs051vcIJ7VakU4HIYsyznvk6tMuRkAoEbCkI+/BACQNm2HIIp5vc7lYjQaE4Ka3t5ePXcl1yBe+z76wlOQ9z4FSAaY3/mJnINWk8mEuro6tLa2oqqqCrOzs+ju7sbo6GjayofJBEHAjh07sH///rSfmXTXPxQKFRRAEVFpYDBDRDlL1SnQOhCRSAR9fX2YnZ3VA45CBINBDA0N4dSpU/D5fKivr0dnZyeqq6uhquqCRfxWy9oSgiDAdP2tAFREHvsl1FAwpw7sUnVyvV4vnnjiCbS0tOCss87Sr5O0ZgugAvKJwyn3y1iVqrYJEAA1RTBTSBWzVNvmu9ZPZWXlkhQCyLQ2EgDI3UeAcAhCRRWE5o4F2y735zJVsn68+KBmenoaPT09GTv4C9a/CYcQ/PE3Yse67q2QmtvzbqPBYIDJZEJTUxO6urpgt9sxNjaG7u5ujI+PZ6yECMSm0LW0tODgwYNZ359kWvlmFgYgeuVhMENEOQkGgwgEAinvik5MTKCvrw+1tbU5J+DHk2UZExMT6O7uxsTEBCorK7FmzZoFa8EoirLovJulZLjwSgg1DVA9s4g89VhBC2VmoyhKQoc/1X4jIyN47rnncO6556K5uTnhOWntZkAQIJ88lHPbNGJ9U6wN4wuDmZXidDqLEszkks8S/7x8aB8AQNp4dsoAbDFBaiGBUC5TroDYKElLSwuam5v16Wd+vz9rO8K/+xmUkUEIVS6Y3/ievNunHS8+mCgrK0Nrays6OzthMpkwMDCA/v7+tDdMAKCrqwtzc3MZ3/NUgZ0gCPpivgxoiF5ZGMwQUVY+ny+hw6N1Evx+P7q7uwHEOhk2my1hv2xTjAKBAAYGBtDX1weDwYCOjg40NzcXLVm5WHLN+xAkA0zX3gwAiDx0H9Q8Ok25LqAYDAYTArzkbY4dO4aenh5cfvnlKRdTlNbEghl1fBjK7FTO7QO0imarK5gRRRFmszlthzxX+azLAgDykRcAANLmHTnvk2t+1JIULEiaEqbl1DQ2NmJqaipjUKOMDyP8wD0QBAHmt/89BFv+P5/a9U0V+AmCgMrKSnR0dKCurg5zc3P6jY1oNLrgepx99tl46aWXsr7W5NccXxhAKyNPRKWPwQwRpRX/hz++1LIsyxgYGMDExATa2tpQW1ubdnHH5A6aqqqYmZlBT08PJicnUVNTk5AHkykA0hbey0Wud7dzClLySJY2vup1gM0BZdgNed8zOe2Tri2p2hYOh1NWZ1IUBXv27EEkEsGuXbvSjmAJ9jKITe2xfU6mnmqWjuBqAqBCGV09wQwQKwQwOTmZcZtiTvtSI2HIp9eXySeYyTZqku86SJmOmes+2khNfFCTnDAf+sk3gVAQ0uYdMOy6Ou/zAbHXk6m8tMZsNqOxsRGdnZ0wGAzo7+9HX19fQqBVVlaGmpoa/UZKJqlynxRFgc/nyzlfh4hWNwYzRJSStqJ2fPAgCAK8Xi96e3tRWVmJtrY2GI3GhOdT0aZ4jIyMoKenB9FoFG1tbWhpadFLucZL15GTJGlBsne6bZeyM5jxeDYHjK++EYCK8MP35rdvUt5JrpXMgsEg/vKXv6ChoQFbt25Ne0yNtDa2Tb5TzfTyzOOjULMk3afKa8q3slmuzGYzIpFIxkIAxTyvfOowEApCqKiCmCJfJpNU7ch1VC7Twpa5yPRZjw9qxsfH0d/fj2g0isj+ZxHd82dAlGB+58cX9fOSbmQmHafTic7OTtTV1WFmZganTp3C5OQkFEXBxo0b0dfXh2Aw9bo+8edMR5s6S0SljcEMES0gy7I+tzy+Izo0NISpqSl0dHTkvM6J1+tFT08PhoaG4HA40NXVhdra2oLWhTEYDAtGZlZLAYB4pte+BZAMiB58HnL30YKOkS6HIxwOJwQz09PTeOaZZ7Bt2za0tramPE48QRAgrt0MAJBPpQ9mUna6q12AJAFKFOrUWMb2p1v/I9v7laq9yY+napvT6cTMzEzW15DtfNkIgvByvsym7cv6+Usewcm37blsbzKZ0NbWFluUtPsU/Hd/DVBVGF/7Zkhta/JvdNL5c7leyQuMWiwWNDU1obOzE4IgoKenBxMTE9iwYUPa6Wa5XptwOMxKZ0QljsEMESWQZTmhdKu2+GVPTw+sViva2toWBCKpOihzc3Po6enB7Owsmpqa0N7envdCj8msVmtJ3EkVaxtguPAqCKKY9+hMKvEds2g0qo+GDQ4O4sCBA9i1axeqqqpS7peqUydpwczJw2lHWFKODIgixLpYQYFU5ZmLIV1J5GzV0iorKzE/P5/xWLmcLxtVVSEfja0vI7Z0IPB/PwvP2y+H57bLEfjPL0AZHynq+dK1oVjHSsdut6P56N8gjg1BLqtE8LVvXdTx8lkwNF0xA1EUUV1djTVr1sBisSAYDGJ0dBRjYwsD61zKZGs/H+FwGF6vN9eXQkSrDIMZItJFIhF9REb7gz81NYWhoSG0tLSk7DADiZ2D6elpdHd3w+/3o62tDc3NzQtyPArthJlMppxzZtK1sViyHc/0ulsBFYj+9Y9QJjJ3cLNJXkBUEAScPHkSbrcbl156adq1fFKNhKiqCrGlC7DagGAAymBPfm2pX31FAIBYR9doNGaddrRY8evLhB/9BaIv/AUIB4FgANE9f4D/c+/Ju7DCUir0Z02ZHEP4N3cDKmC97SMIChJ6enoKupkgCAJCoVDC74FCRsTiVVRUoLOzE+effz6efPJJ9Pf359y2VIUBtN99K7UeEBEVjsEMEQGIBTKBQEDvLMuyDLfbjXA4jI6OjpRJ5xpVVTE5OYnu7m5Eo1F0dHSgoaEh7VSyxZatLWT/Qjt16c6lBQrpjit1bIC0dScgywg/9ouCzp3u/Pv378f8/DwuvvjigqbrCZIEqWsTgNjoTC7n1Iiu2MhMqrVmVlpVVRWmp6cL3j+Xz4h88hAQDgMWKxAMANGItjMQlaF6ZxD531+n3T/f9VEWq9Bjh356FxAMQNxwFkyXXYf6+no0NzdjYmICAwMDed1UUFUVPp8vIT+ukBGxVOrq6rB27VpEo1FMTk6ip6cHHo8n47FS5aZpv/NYupmo9DCYISJ9moX2R93j8aCnpwe1tbVoaGhIu5+iKPqid4IgoKurCy6XK++FD/NhtVqzdlaKKdt0lUydRdN1twACEPnT76D6F05jybWSmiYSiWD//v2w2WzYsSP3KlqpSGs3A2rqimYZF850nV5rZmx4UedPZzEde7vdDr/fX3BRiFzOLR+O5ctAMgJqik6voiJ66Pm0++ea2L+SogefR/SvuwFRhOXdn4Bw+ufZZDKhtbUVVVVV6Ovrw9jYWM7X1OPxpCwVXgxbtmyB2+1Gc3MzWltb4fF4cOrUqZynjmlVFFVVhSzL8Hg8GYtJENHqwmCGloQsy/jwhz+ML37xiyvdFMoiFArB5/PpdyZHRkYwPT2tr9ANpM5jGB8fR09PD0wmE7q6ulBdXV200Y9MHaRiLZKYTrE6lqqqQtq+K1YG2edB5I8PLupcoVAIf/7zn9HW1ob169fndKxM11FaswUQAPnkwZzbAACC6/Q0s7HhJVs3pZCARtvH4XCkDXaL8d7KR2LBjFBWcfrECY0AIEKwOxZ9nnQW+xqyvmfRCEI/+joAwHjVGyB1LPys2e12dHV1wWQyobu7e0HhheT2KooCWZaXbMFbo9GIuro69Pb2wmAwoLGxEe3t7ZidnUVvb++CoCZdCfn4z6vH4yl4SisRLS8GM2cwt9sNQRBw+eWXJzz+xBNPpHw8H5Ik4eDBg/jiF7+I0dHRxTWUloxWmlQQBITDYbjdbpjNZrS2tqZcZV5VVUxNTaG7uxsGgwFr1qyB0+lcdAcref9Mx9PK8C7V1JxiHVcURQiiCMP1twCCgPD//hxqtLCF+nw+H5555hmsX78+ZcUyIPeSv3r7ThcBUAZ7U44apd3v9MKZ6vhg1vddez7fkbrFrJ1SU1OTtnO92NLQajgE+UQs+DNces3pE+PlERpBAKDAeMk1BZ9Da2c6i50Cle3aRh77FZSBXgjlFTC/9Y6M22qlk0OhEHp7exEOh1Oez+PxwOFIH+AttlCDIAjYsGEDent79etjMBjQ3NyM5uZmTE9Pp1w/J9s5fD4fAxqiEsBghpbMTTfdBFVV8eCDC+9I08rz+/0IBoNQVRV+vx/9/f1obGxMmeQvCIJenUyWZXR1dSVsl66cbvzzxQw+HA7HgspVKyHTa9KeM116LYTKaqgTY4g+93je55idncVzzz2HHTt2oKysLGFdn2wyBjPOGgiuBkBRIJ86kvMxxbrYNDPVMwfVl9t0v6UokZyOwWDQRwJSWUzgLZ88DCHkh1BZEwtmBAGACkgG4HTAZrjotTBcdFXB58jWxqWckqZMTyD0qx8AEGC69UMQyiozbq+tG1NfX4/GxkYMDg5ifHx8QRntmZmZtMVDtG1SfZ9um1TPSZKEpqYm9PQkFrQwGo1obW1FQ0MDJiYm0N/fn/NimYqiwO/3IxIp7CYEES0PBjO0wHnnnYejR4/iJz/5yaKOc9NNNwEAHnjggcU3iooq/g/07OwsRkdH0dHRkbIqls/n06sYtbe3w+VyZR1JSb57nJwov9gOWXV1ddYV35dDTneUTWYYr3ojACD80L15ddonJiawd+9eXHjhhaioqEAkEskrmMl2LmnNVkAQ9NXscyFY7RAqqwEAynjx8maK2UmvrKxMWQhgseeQD++DogiQNp2D8I++AUSjgKICsgwYzbB+7i5Y/v5fTgc5uVnp6lnx5w/97NtAwAdxzWYYr3hdxm2BxOtpNpvR2dkJURQTqp4FAgG90txSW7t2Lfr6+lKOXmkjzi6XC6Ojo/qioKloN19EUYSiKPD5fAxoiFYxBjO0gM1mw4YNG9JOZ8lVR0cHtm3bhscff3xZE7YpM7/fj3A4DFVVMTIyAq/Xi46ODr0qltZBCYVCcLvdmJ6eRmtrK+rr6yFJUk5Ti/JdGDFX2n4GgwEWi2XJ14YoVgfb+Jo3AiYzlJ6jes5FNsPDwzh06BAuvvhi2Gw2ALECAJmqyuVLWqetN5N7MAMAQm2sKMRSrTWzWBUVFUsycicf2RdLhrdYIO99Sh+NgapCrKmHYeu5OX3+ixnYL5Z2/ujR/Yj+5VFAEBKS/lNtm0lNTQ1aW1sxOjqKkZERTExMoLa2Nu/25Lu9NjrT3NwMt9uddnuLxfLyoqB9fQtGkrRjxldNFAQBfr+fU86IVikGM7RAMXJmNDfddBPC4TAeffTRxTeMFk0LZBRFQV9fHwwGA1paWhI6EFoRgJGRETQ0NKClpSUhcTfbNJClvNMc306Xy4Xx8fElOxdQxPyZCieMl18HAAg/9LOs2/f19eHUqVO49NJLYTab9cfjF8wsBmntFgCxIgD5vFY9b2aVBjPaSECu04lyEcuXeSlWNOHw6UUzG+Ju+FisafZMVGhp8aWkylEEf3g66f+KGyGt2byo4xmNRv0GSU9Pz5IGAckLiK5ZswZ9fX1Z99OKGEiShFOnTuk33NIV0lBVFV6vlwEN0SrEYIaWFKearR5aIBOJRNDb2wun07ngjqmWF2O1WtHe3p7QkV5pyR1Ao9EIs9m8ZKN+xe5wmq69OTala+/TkAfSL1TZ09ODoaGhlGvIKIpS1LLXYsd6wGAEPHMLApOM+TZ1sbVmlnPhzHzv2DudzpSFAAodCZFPHgIiYQiV1bD+6w9hfN3fQZl6eeV5wZx64dJkqyGQSb4GkT/cD7X/FOAoh+nWD6Tcp5BFLv1+P84991zMzMxgcHAwZR7TYpP/k9smSRJqamowMDCQ0z7V1dXo7OzE/Pw8+vr6sgbAXq+XZZuJVhkGM7SkzjnnHLS1teGxxx7jnOMV5Pf7EQqF4Pf70dfXh+bmZpSVlenPh8Nh9Pb2wufzobOzE5WVlXmfY6mnzqQ6Zn19PcbGxpZkkbt064EUutif2NQO485LAVVF5NHUi2geP34c4+PjuPDCC1MGLcXuCAtGUyygASCfenmqWbaCDaKrEVAAZTR7MFPMUtf5bGu321OW5C100UpteqC0aSckZw0MOy4Bgv6XR2RyDGaWSr7XR6PMTSP08+8BAMxvfR/ECmfKffJ9H+fn52E0GmG329HS0oKKigr09vZibm4u73Zn2ya5bevWrVtQCCDTPpIkobGxEXV1dRgaGsLo6Gja3ynaCA0X1iRaPRjM0JK78cYbMTc3h8cfz7+SEy1eIBBAKBTC7OwsRkZG0NHRAbPZrE93GR0dxdDQkF6RqBh3/otVvSpbB0q7Czs2NpZxu2IppCpb/GvQyjRH/vIolNmphO2OHDkCj8eDCy64IO3rzvfxbFRVfTlv5vjLwUzWnI+6JkDMbWQm3+pU6c6dz/aCIEAURVgsloRyvIu5fvKh2NQyafPZsX+/+BwAAWJjW+wY5tymmS2VQj8D4Xu/C/jmIbavg/GqNxTluKqqYmxsDPX19foxysrK0NnZCZ/PlzH5vhjMZjPsdnteRUIEQYDFYtELofT09CyYeqYVBQDAgIZoFWEwQ0uOU81WTigUQigUwtjYmD7qok1d8nq96O7uhslkQkdHB6zWWGdsUetw5LFvLp2kXI5XWVmJUCiUdQ2JxbSjWKSN50BcsxkIhxDZ/Rv98ZdeegmhUAg7d+7MuH8+Hf1cp+9Ia7YCAORTh7Nur9GmmakTo1ALnHJTaKJ3smwLrMZPNSu48EQ4pBdJMGyJvUfRA3sAnB6lUhUIpuKPzCzVZ1M7rnziICKPx0rnW979SQhJ0xqBwkZ8hoaGUFNTs2CapCiKaGxsRE1NDfr6+pZ08du1a9fi1KlTCY/lej2dTic6OjowOzurT4+LLwqgqioURWFAQ7RKLM1yvPSKdPvtt2fd5p577lnwmFYVLdscZiqucDiMQCCAoaEhvcoPEOtwDA8PQ5blhCpmmnQJsMWY275UtApGqV5PNsuZwyAIAkzX34rg//ssIr//DUw33oaXjh2HIAg455xzMu4ry3Jeo2bxBRkyvS+Stnim+zjUcAiCKXuelFBVG8u1iUagTo1BcDXm3K7lZLfbExbtLThf5sTBWL6MswZCQyuUuWkovccAAKbbPgrL+z+bVznmXC3lwrCqLCN4978DKmC47DpIG85a9HFFUdSDx0xTVW02Gzo7OzE8PAyPx4OmpqaUn+3FFEuoqKhAOBxGMBjUS87neiytMlpLSwvm5+fR09MDl8uF8vLyhO1kWYbX613wOBEtLwYzlLMf//jHWbdJFcw89NBDAIDrr7++2E2iNKLRqB7IGI1GuFwuAEAwGMTg4CCqq6vhdL48Nz5bp2Gly8dmYzAY0NDQgIGBAbS3t6/KilEawwVXQKithzoxit6ffR/iuVdg69atWfeLRqMJVeVylXXKmKsxtqjn7BSU3uOQ1m/LfkxRhOhqhDLcB2VsMDY6sUpZrVb4fD7Y7faCjyEfPp0vs3E7RFFE+ODfYuWY29dBqq0vSjuX+zMb+fPvoPQcBewOmN/2oaIcMxQKYWpqCp2dnVm3FQQBTU1NerDQ1NSkjw5rFns92tvb0d3djS1btmScppguj0oQBJSXl8Nut2N4eBjz8/MLpuJqIzQOh2NRbSWiwnGaGeVMG17P9JXKAw88AEEQcOONNy5zi89M2t3Cvr4+mM1muFwuKIqCsbExjIyMoK2tTQ9klqOccjHkEkzZ7XbYbDaMjY0VlNsSbynviAuSAaZrbwGgomLPH7Flc25lcAsNZrK2RxAgdW0CoMZGIHIk1McCmGIunJlNIe9Luqpm+dCT/7fugKqqiL4Ym2JmOPuCRR033nL+DKqeWYTv/Q4AwPyWOyA6axZ9TFmWMTAwgObm5rxufpSXl6O9vR2jo6MpS60v5kZKS0sLRkdHM17bdL8rkgsEtLS0oLy8HD09PfB6vQnFQKLR6JKveUVE6TGYoSU1NTWFp59+Gueddx4aGhpWujmveNpdQrfbDbvdjpqaGoTDYbjdbkiShI6OjoR1SlZ6xCXXPIhcO3oulwuhUAjT09OLem1LnatwpKYNstkG0/Qo5L3P5LRvNBrNewpdru0R120FIEA+kUfejKsZUFWoWSqa5dtJL8YIYfwxrFYrQqFQ4fkyoaAe5Bk2xYIZ+cBzAABp2/kFHXOlhX7+PaieOYgtXTC+9k2LPp6qqujv70ddXV3e5dxVVYXBYEBHRwcAwO12JxQHWMwNF0EQUFtbi+HhzAF38ucq3bnKy8vR0dGB6elpDA4OJjwXiUQY0BCtEAYztKQeeughyLKsFwGgpeXz+dDT04OKigpUV1frf3SbmppQU5P57utKjM7kW9EqF9o89+QSsKvF/v37YXCUw/LaNwIAwo/cm9N+SzEyo5HWbgKQWJ4ZyLLWjKsREABlLL+OYjbFCCSTj2Gz2QruaMonDgLRCIRqF4SGFih9J6HOTAIWa1HyTJab3HMMkT/8FoAK87s/AUEq/DOlXef+/n44nc6CplrFVwpzuVxwuVxwu92Yn59PuV2+Ojs74Xa7C2pTKpIkobW1FTabDT09PQiHw/o+iqIUXIiEiArHYIaWlFbBjMHM0vN4POju7obT6URlZSUGBwcRCAT0UszZrPQoTbEIgoC2tjZMTU0t6Z3SQoK/AwcOwGAwYMuWLTC99q2AZIB8eC/k7iNZ9803mMknB0Pq2gwIAtTJUSjTE/rjGUdJ6poACFAmlm+aWaGf0aqqqoKnmulTzDaeDUEQEN1/elRm03YIRlNBx1wpqqIg+MOvA6oKw0WvgWHzjsUdT1UxNDQEm81W0NpU8bT3VisOMDs7i+Hh4byrqSVv73A4EIlE9KAjfttcjpeurU6nE42Njejr64PH44mN2Mnyoior0so5ceIE3v/+9+O+++5b6aZQARjM0JLx+/3YvXs31q9fjw0bNqx0c17RvF4vTp48CafTCbvdjt7eXjgcDjQ1NaXcfrE5JatBtulI2jx8ba2IYsu3Y3348GEoiqIn+4s1dTBcdBUAIPy77KMzsiznNc0s1wp0ACDY7BBbumLnybFEs1h/ujpeDmvNFEuhn1mz2YxIJFLQ/nry/+mSzPJLzwGCUNR8meUSffIRKCcPAlYbzLd9ZFG/B1RVxcDAAEwmE2pra4vaTlEU0draCqvVip6eHoRCoZz2S17UVnttra2t6Ovry7sd2abBms1mdHV1YWZmBqOjo/oNhGAwuCB4oqXjdrshCAIuv/zygo/R3NyMn/zkJ/jSl75UvIbRsmEwQwtcfvnlUFUVTzzxxKKOs3v3bgQCAY7KLDGfz4fjx4+jrq4OBoMBfX19aGxs1O+UFmsl+3hLEQgVY7HEeKIoorOzE5OTk4tOAF+s48ePIxAILCi/bLrhVgBA9Lk/JSTSx69noVmKnJl40tpYkKWcPJRlyxixNpYDp87PQvUtTcBYTHa7HT6fL6991GAgLl9mO9SAD/KxF2P/PuvCYjdxSaneeYTu/Q4AFeY3vgtitavg3wOKoqC/vx92u73ogUw8p9OJlpYWDA4OYmpqasHzWSv1nX59LS0tC/Jm4qe35UvbV1uctbW1FUajET09PYhGoxAEAYFAAJFIJO9j08qw2Wy46qqrcOzYMZw4cWKlm0N5YjBDS4ZTzJZeIBDAkSNHUFdXB7/fj4mJCX0F66W0FFPSliJ/RhRFtLe3w+PxYGJiIvsOS6C7uxszMzMpF8SUOtZD2roTqiwj/Ngv9Me1UZXku8xLGsysO503czK3kRnBaodQUQUAUJZxdKZQlZWVeS/SKJ88CMjRWL5MfQvkw/uBaBSobYTQ0LI0DY1TzJ+z0K++D3V2CmJjB4zX3lxwe7RApqKiAlVVVUVrXzomkwmdnZ2IRCLo7+9PWKQy16liBoMBRqMx5bTTdOtq5fNvAKiurkZ9fT3cbjf8fj9UVYXf708oZkCrm9ZXuf/++1e2IZQ3BjO0JGRZxsMPP4yGhgacf35pVvxZ7cLhME6cOIHa2lpMT09DURS0t7cvWYe3VKelCYKA1tZWRCIRfQ7+cuUHud1ujI2NZfwZMF13KwQBiPzxwYwjHIqiLGkwI67ZAgCQu49AlXPrgAl1p8szZygCsFo+NxaLJefpShr58H4AKsT1p/NlXnwWAGA858Jl+QwV69rJ7pOIPPZLAID5XR8vONcnGAyiu7sbNTU1i86RyYcgCKivr0dFRQV6e3sXjHjkcp1aWlrQ39+f8/ky/TvdPjabDR0dHRgZGcH8/DxUVYXP51s1PwOU2Q033ABJkvQbsVQ6GMzQkpAkCZOTkxgeHn7FJJavJoqi4OTJk7BarZiamkJFRQXq6upSbltomeNkpf4+NjY2wmw2w+12IxKJQBkZQPgPv4ktHjiX/zS0bNPiBgcHMTAwgAsuuCBzdaTtuyA2dwBBPyJ/fDDtdks9tU9s7gBsdiDohzLQk/K8yd9ri2WqY4llatOdIxfpXmcxSjxbrVb4/f6cjyEffgGAAMPWcwEAUa0k81mr+wZN8vsU+u9/B1TAcP6VMBTYdo/Hg8HBQbS1tcHhcORUYKLYn9mKigo0NTWhr68vYcpgLp+xpqamlOvY5PIacikXrv1fKzM9PT2tT41jyebSUFNTg127dmHPnj0YHR1d6eZQHhjMEJUYRVHQ3d0NRVHg8XhQV1eHioqKlNumGoUo9aBkMaqrq+FyuTD5rX+F7yNvQuj7X0HwO/8Hvvdfh/Cf0gcSqWSaFjc+Po5Tp07hoosuSlgtPN32xutjuTPh//0F1OjyzbOPfw2CKEJasxmAEJteFde+dN+LdbEiAMVcODPd57MYJZ4rKipyzp9SgwG9GIJhy3Yoo4NQR/oBUYJhy8Ipg6tJ/GuPPvN7yEf3AyYzzLf9Q0HHGx8fx/T0NDo6OmAyxUZ1chnhzGUKV6ZtU21vsVjQ0dGBiYkJTE5O5tJ8ALEpp2azeUFgUchriKdNe4u/HqIooqOjA4FAAMPDw4hGo3kF0bRybrrpJqiqigcfzO/vAa0sBjNnsMrKSnz+85/H7bffvtJNoTwMDAxgdnYWoVAITU1NKCsrS7ttIXfFV0Ows5RtMP3tT7A/8xgAFcDp80SiCP3XlyH3Hlv08WdnZ3Ho0CHs2rUr52lhxkteC6GyGurkGKLP/invcxarOp209vRUsxwXzxRdjYAKKGOJOTOr4TOUit1uRzAYzGnb2PoyUQg1dRDqmmOjMoIAacNZEGz5r6eyElS/F6Gf3gUAML3+nRBd+S1cHIlE0NvbCwBoa2vLGpjnohiFPrRcuEgkgsHBwZw/+83NzTlPNcvWhuTnkn8GFUVBc3MzJElCf38/QqEQK5yVAC1vhlPNSguDmTNYZWUlvvCFLzCYKSFjY2N6VZ7W1lZYLJbEu+tpqhPluuZIPmuTrJTFti/8v78Bkq+RoAKimHGaVy68Xi+ef/55XHDBBTAajTnvJ5jMML7mzbH2PXRvyteYbapLMQII6XTeTK4VzYT65tMLZyYGM4t5j5Z66pLZbM4poHl5fZntEAQB8oHnAKiQthU+xazYP1vZjhf6zd1Qpycg1DfDdOPb8jr27Ows+vv7UV9fD5fLlfe5M1nsvlpQ1dDQoJeizyXRvr6+fkEhkEJ/blKNeCf/LgYAl8ul5/p4PB4WBFjlOjo6sG3bNjz++ONLVtafio/BDFGJmJ2dxdGjR/U52dp0j3iKoqTtCBfyR3ul7rDnMke94GNPjwPa8VUVsREaQJVlqDOFVzwLBoPYs2cPLrjgAthstrz3N139BsBsgdJzBPLBFxY8vxzvhbg2VtFMGeqF6p3PsjUgumLrGKkTozkXDchmsdN+sqmoqMipqpkWzBi2bIcajSB6aC+Axa0vk2vbc+3sZzqe3N+NyCOxCnmW2/8x56R/WZbR398Pn8+Hzs5OWK3WvM+dzWL3jb8+TqcTDQ0NehWxTIxGI0RRTBghWcw6O6naluqxyspK1NXVwe12Y35+PqEiG60+N910E8LhMB599NGVbgrlKPflpIloxfj9frz44ouw2+3o6urS/6AvRz7Mapl6livtzm26TorYuQHyi88BclSfZQYIgADMO6ohhkIwm815nTMajeKvf/0rzj77bDgcmacgpbueQnkljJddh8ju3yD86L0wbDs36z7FJlZUQahvgjoyBPnUkawdd6GqFjAYgWgE6uS4Xt1sKRTrGjgcjpSJ4AnnCgYgnx6dkjbtiE05C/ggVFRB7Fi/6DZks+iAXVURuucbgByFYeclMOy4OKf9pqenMT09jfr6+qyf42JazHurqiqsViva29vR398Pp9MJp9OZdvv6+nqMjIygra1t2doHxKY41tXVobe3F2vWrEmb50jFcezYMXzlK1/JuM2GDRvw6U9/esHjra2tAGJTuqk0MJghWuXC4TBeeOEFWCwWdHV1FTRvvdA/xisRyCz2nNmmyplufDsC+/96eqrZy3kzAgBb3zGMnDoBc1UN6urqcrrWqqri2WefxcaNG1FdXZ21bZmYrr0ZkT/8FvLeZyAP9EJq6QAQu1u+lGWZ40lrtiI6Ogj55KHswYwoQnQ1QhnugzI+CHEJg5lifQ4FQYDRaEQ4HE45ugkA8vGXYvkytXUQ6pogP/47AIC09VwIRcgbKZZ0PyvRZ/8E+eDzgNEE820fzXqcYDCIkZER2Gw2/WbJYs6fr2KM8mgj1kNDQ/D7/WhsbEx53KamJhw4cEAPZgotZFAIh8MBVVXR3d2NDRs2FDSCS7kZHR3Fj3/844zbXHbZZSmDmYceeggAcP311y9J26j4Vs9vZSJaQFVV7NsXm+6ydu3ajCMOmZTSyEqx25p8vQybtsP6ia9BqGlA3NBMTPcR1N79ZViDPvT09OQ0Hen5559HU1MTGhqyJ1dne+/EpjYYzr0EABB55Of644qi5HVdFjNNT1qzCYAA+dTBlM8nl/0V6rUiAMWpaFbI4qnpykenk62q2cv5MjsgCAIiL+6JlTZexBSzQmRbpT5ltbCgH6GffBOqqsJ0020QMyzuKcsyRkZGMDo6iqamJtTV1eX1OVttv1cEQUBzczMsFkvaPBqbzYZQKKRf02JUyctn+7KyMtTW1uLIkSML1suh4rn88sv1ogzpvp544okF+/n9fuzevRvr16/Hhg0blr/hVBAGM0Sr2KFDh+Dz+bBp0yZ9lKBY63astOXqCKU6j+G8y2D/9v2w/+evYfn0N+I3hjI1jjKDiM7OTgSDQfT29qaci6+qKo4cOQKr1YrOzs5Ft1N7n4zXxco0R/7yCJSZWOlZRVHyGpHLteOfirTudEWzk0ey5gUIggDRFSsCoI4PLdi2EPlWu0rVpmzKysoS1ilJpuUsGbZshzI3DdV9DBCgJ/8v18+UlluRz89K+Lc/gjo1BrGuEaYbb0u5jaqqGB8fR29vL2w2G9rb29OOUpUirQR7X19fyoChrKxMXwMmX8VY70gLaA4dOgRZlgtqBy2N3bt3IxAI6FXNqDQwmCFapYaHhzEwMIBt27bBYDAsqFiVLtk0l8eWU7EWQVzs+ZIJogixoRXGHRdDisspEKpcEBtaIIoi6uvr0dzcjKmpKfT29iIQCOjb9ff3Y35+Hlu3bi1Ku7X3Sdp4DsQ1m4BIGJHdv9FfU6HTBPMltq8DjCbAMwt1uC/79qeLACz1yEwxSZIUq1CWoiOpBv2Qe4/Gttu0A/LBvwGqCrF9HURnDYDFBYv5yPc9V4b7EX7oZwAA8zv+EYLZsuBY09PT6O7uhiRJ6OrqesXmbjgcDjQ1NcHtdiMUCiU8V19fn3VRxGLkLWV6rKKiAk6nE0eOpL5pQCtDK8nMYKa0MJghWoV8Ph/27NmD7du3J5T4zTadppApOrnItfrOagimCjmf+a13AKoKVVWgDvYg/Nv/1p8zGo1oaWlBY2MjJiYm0N/fj76+Prjdbpx33nnFbDqAWPtNN8TK6EZ+/1sowQBkWS4oV6qgCnZGE8TOjYhNNTuSfXtXLE+mWMHMclBVFWVlZZifX1ixTT5+en2Z2noIrkZEX9wDIPcpZrlc8/g1SYrVkVVVFcF7/h2IRiGdcwEM516a8JwWxEQiEXR2dqK6unpFbnQsZ8fdYrGgra0NAwMDCaOrLpcL09PTGfddbDtz+V1YWVkJm82Gnp6eRZ2LikOWZTz88MNoaGjA+ecXXoKdlh+DGaJVRpZl/OEPf8D27dvTlkXN12L/MOfakS7VO4xSxwYYzrsMwulfieHf/CiWBB7HbDbra/vs3r0bTU1NOS/AmA9VVWE4/3IIrgaonhlEn3q0aOvI5EpaFyvRLOew3ozY0AwAUMYHCzrXSn1mKioqUq4jIR/eCwCQNm0HVPX0+jJY1PoyyeLfz+T3tdDrEX3+L5D3PwsYjLC84+N6IYzJyUl0d3cjHA6jo6Mj58IWi21PvFQjysv1eTaZTGhvb8fo6Kj+fhuNRiiKkvMUr6X8jFZXVyMUCmWtsEdL76mnnsLU1BRe97rXrfiMBsoPgxmiVebpp59GV1cXysrKirqAYKkGGukUu4NvetN7Yt+IIqAoCNz1eaj+xLyKcDiMgwcP4pZbbkFLSwump6fR09OT8g5/rpLfF0EQIEgGmK69JXbOh+6DHIksbzCzRsubOZx1W7H2dOEDz1xOa9MkW6lOg9FoRCQSWXD9o0f2AwAMm3ZA6TsJdXYKsFghbThrWdpV0HTCUBChH38DUAHjdTcDDS0YHx9Hd3c3AKCrqyttEJPt90Ix3p9so8hL/bvJYDCgvb0dU1NTeuGHqqoqTE5O5rT/UnxG44/Z0NCA4eFheL3eop+HcscpZqWLwQzRKnL8+HGoqoqWlhZIkrTgj3z89BQg8Q9itg7DK+1OU/K1WAxBECB1boD5jn+C7ev3Qqithzo2hOA9LxcHUBQFzz77LLZu3QqHwwGz2Yzm5ma0trbC7/eju7sbExMT+pS8xS58aLziBsDmgDrSD+XAsxnvphe7w6kFM0rfSajBQLpdYue22iFUxkpSKxOlM9UMiFW2ip9+pAZ8UE7FAjhp8w5EX3xO/z7XRSeXQ/JnK/zAPVDHhoCaOkxcdC3cbjeMRiO6urpQU1OT8fOxGn4vLMsaSqKItrY2zM/PY3x8HHV1dZiYWLhI7lIGVukCOFEU0dLSgpMnT7LC2Qp68MEHUV5ejiuvvHKlm0J5YjBDtEpMTU3h+PHj2LZtG4DUSd+ZRiOWM1/llTbKo70e09VvhNTaCcuHvwAIAqJ/fgiR5x4HAOzduxetra1wuVwJ+xoMBtTX16OjowOiKKK3txcDAwOLnoIm2OwwXf0GAIC4+zcZg5miTwWqrY8tiClHIfcey75vbUOsPPPIwopmq+Gzki6oLy8vTxhVk48fBORYvoxY1wj5pVgwYzhreUsyZxP/GuTRAYQe/B9AEOG97u2orm9AZ2cnnE7nigUqy/me51tKuq2tDdFoFOFwOGV57qW6Zpl+d6uqCkmS0NDQgBMnTuSco0jF8+KLL8LtduOaa655RVX2O1MwmCFaBcLhMJ5++mmcd955CzqthVYDW8oORa5/8FfDXd9CGDZth+mmWFnb4PfvxKnnn4XRaERHR0fafURRRHV1tX43fGpqCt3d3Ziamiq4c2J8zZsByQDhxEsQ3CcLOkYq2ab4CIIAac1mAIBy4nDa7TRiXVOsPPPEwmBmNXwG0o1g2u32hJEZ+UisJLO0cSfUgA/y0RcBxIKZ1RCUAS+/lmAwiOHhYUx/904IkTDErTtRf/1bVnwhxqVcaDefoieZNDY2wmw2Y2RkpKBjZhsRTyXVKHsyi8WCsrIyuN3unI5JxXP22WdDVVX8/Oc/z74xrToMZohWgb/85S/YtGkTLBbLgufyGYmJf65YicX5nDdZKd9hNL35vRDbN0Kdn4P1vm/jrNMjZrmwWq1obm7Wgx+3242+vj7Mzc3l9T6INXUw7LoaACD98Tf5vYAMclmXRdTzZg5l3A44HcwAUIq01sxyMhqNCIfDAIDo4dP5MlvOgXx4HyDLEFxNEBtbc65SthS040ajUYyNjeHUqVOYmJhAufsYLEdeACQDLO/8xKoLHFfzsV0ul77WS/LvqWznKcb03XT7VVRUIBQK5bRgLxHFMJghWmFHjx7VF1FLVmjnKNV+hZT2Xeyd0NXQucpFqrumgtEE+b2fgmowoHzgBCKP5H/HThut6ezsRGNjI4LBIHp6ejAwMJBzsq/phlsBVQX2/gXK+HBRc4UykdbFRmbkUzlUNKs7XZ55vLRyZgRB0Es0qwEflO6X15eJnq5iZjg79ypmSxHwyLKMmZkZ9Pb2YmhoCCaTCV1dXWiurwPu+xagqjBe+xZILYtfuHUlrOTviPb2dsiyDLfbvWoWr1RVFXV1dXC73YhGoyvdnJJQWVmJz3/+87j99ttXuim0QhjMEK0gr9eL7u5urF+/Putq68Di7vwWsm+pzbkvdL9UuUnRaBQvDI5B/LsPAwBCP/sW5L7Cp3oZjUbU1dWhq6sLtbW1+ns/MDCAubm5tKNYUvs6yBu3Q1AUhB/7RU5V3IoR7EhdGwFRhDo1DmVyLOO2Ql2sPLM6Ulh55pWiqirKy8vh9XohH3spli/jaoBY1/hy8v+2C4t6zuRRsVTvVSQSwcTEhJ5/paoqWltb0dbWhsrKSgiCgPDv/gfq6CCEqlqYtUp8S2S1TLErttraWoTDYT14WMmAJrkgQH19PdefyVFlZSW+8IUvMJg5gzGYIVpBzz33HDZv3rzoylerwUqufL7Y/VLZs2cPNmzYAMf1t0DacTEgRxH85r9ADYey75yFxWJBfX09urq64HK5EAwG4Xa74Xa7MTU1teCObOTKG2P//9ODOZU/LsZ1ECw2iK1rAGRfb0Z0NQFQoUyOQZUXdzd5uT/jkiRBURREtXyZTTugjA5CHR0AJAMMW3cs2bnj80sCgQDGxsbQ09OD4eFhGI1GtLW1ob29HVVVVZAkSd9PGR9B+P57AADmt/09BJtjydoIpA+6imElAyWHwwG/3w+73a4HD8UOaPL93a7932q1QlGUrIt7EhGDGaIV09PTA7PZjKqqqiVbFHE5OgraOXJtf7GSeJfSkSNH4HQ60djYCEEQYHn/ZyFUVkMZ6Ebo3m/r2xWj3WazGXV1dejs7ERzczMEQcDQ0BC6u7sxPDwMj8eDyLqzgKZ2IOBH5E8PLFuHX1qr5c0czLidUFULGIyAHIU6mbj432p7b1Ox2+0IH4wtlmnYvF2fYiat31b0QEF776LRKKanp9Hf34/u7m5MT0/DarWio6NDH4HRpoYmv9+hn/w/IBSEtPFsGC55bVHbl63dy2k5PjuCIEBRFNjtdjQ2NqKvry+vgKbY6/Rox9Ommw0MDHC6GVEWDGaIVkAwGMTBgwexefPmJT3PcnRAijIKUKR2FqPzMzw8jNnZWWzatEl/TKyshuX9nwUARB75OaIH9gB4ud3xHZDFMBgMqKqqQltbGzo7O1FZWQm/34+BwUFMnxtb+yD06C8gF2F0KBfS2tMVzU4dybidIIoQXVreTOJUM1EU88rzWYngp8woAadLUEubtkPWgpltuefLZBONRjE7O4vBwUE9UFVVFQ0NDejq6kJTUxPKy8uz/ixED+xBdM+fAVGC+d2fzFjudzksddXEYh0/3XEcDgfm5uYAxIJal8uVNqBZivL3mV6fIAhwuVzo7e1d1DmIXukYzBCtAG16mdbRS6cU7mrnazVXO/J4PDh69CjOP39hJ9aw42IYr34TACD4nX+FOj+74LzFfG2CIMBms6Gurg6tra2ouvYtQEUVMDWBkQd/jp6eHoyMjGBubm7J7twKp8szy91HoEYzL+Yn6BXNEosAaFOpVmM5b319od4TEGQFgqsRQlUtoodeAFQVhrMLX18mFAphamoK/f396OnpwdDQECKRCKqqqtDV1YXW1lZUV1fDaDTm3t5IGKH//g8AgPG1b4TUthbA8q4xVeh5ipXPVqh0x6mqqkpYb8bhcMDlcsHtdi/IY8vlNeT7OlMFbPFttVqtCIVC8Pl8eR2X6EzCYIZomY2OjiIcDqOmpibrtqkKAKT6o6zd+c7lD/8rdbrIYsmyjOeffx7nnXdeQn5CPPPb/x5iYzvU6TEEv39n0aeYpKOqKgwWK0yvfTMgAJV7dqO9vV0v46pNS+vv78f4+HgsoT3uznK2dWXSkZraAVsZEA5D6e/OuK3oOl0EYKx0yjNr7498dB8gAOLGcyCfOAgE/BAqqyF2rM/pOOFwGLOzsxgZGUFPTw96enowPj4OQRBQX1+Pzs5OtLW1oba2FlarteD2Rh79BZRhN4TKapjffIf+eCn8fKX7vbXSnE7ngsUzMwU02RRSnCNboZeGhgZ0d2f++SM6kxlWugFEZxJZlrFv3z7s2FFYUnG6aRfJ050yWYkOxGouXKB54YUXsHbtWpSVlaXdRrBYYfmHL8H/z+9CdM+fEX3iIRiveF3a7Yt9rU1XvxHh+++B4j4B5dALsG07L2GRxEgkAr/fD6/Xi8nJSSiKAlEUYbVaYbFYYLVa9dWtc/nMCKIIae1myAeeg3ziIKTODWm31cszj5VWeWYAiByO5cuEOjZC0qqYbT0XQlI5c0VREAwGEQgEEAqFEAqFoKoqjEYjrFYrKioqUF9fr/+cFvNzr0yOIfSbuwEA5ls+CMFRXrRjp7OUC2ACxQ32Cz1WeXk5PB7Pgse13wN9fX1oa2srqLR9qjYW0k5JkmA0GjE9PY2qqqpFtYPolYjBDL2iBQKBRd0JLbbjx4/D6XTCbDavdFNWtaXuRCXr6emByWRCS0tL1m2lzg0wveV9CN/3bQR/9A1IG8+BWJ99v1ylClj1jlB5JYxX3IDI73+N8CP3wrDtvITtjEYjKioqUFFRoT8myzICgQD8fj/m5+cRiUT081gsFpjNZv3/qUakpK6NsWDm1GEAb07f7tPlmZUSGpkBANXvg3o6J8jT2AHTXx4BAEQ3nI3JyUmEQiGEw2H9PbBYLLBYLHA6nbBYLAUtaqufO+lznulzH/rpt4CAH+K6rTBcfl2+L7MgpXATAlhcO0VRTPselJWVQVXVogQ0i72WWi7PagtmVtvfWDozMZihVyy/34/Xv/71uPzyy/HhD3844x335eD1etHf34/t27evaDvytdyBBbA0naj4qmvxr2lmZgb9/f249NJLcz6W6ca3QT7wLOQj+xC46wuwfel7EKTi/DpNN1Kitdd03c2I7P4N5H1/hTzQk3WxREmS4HA44HAkVuWSZRmhUAjBYBBzc3MIh8P61DRBEGAwGGAymWBu7oIEQD5+MONn4eWFM1fXWjPJbZZlGZFIRP+SDzwLC1REq+vQPzIKZ09s4Ux/1xaYDQY4HA6YzeYl+UymWt8olejhvYj+9feAIMDy7k8mjBitxM/narSYYgGSJCEajcJgMCy4luXlsRGwvr4+tLe3r9i11kZYR0dHUV9fvyJtiHf48GF8+ctfxrZt2/DpT396pZtDZzgGM/SKZbPZ8L//+7/43e9+hze84Q246qqr8KEPfQh2u33Z26KqKg4fPgyXy6VP88m3pPFKWe3tSyVVBy95sUIgNi1r3759uOiii7LedY3vLAmSBMuHPg/fp94G5cRBhH/7I5jf/N6c2lGIhAX1GlphOPcyRP/2BCIP3wfpA58t6JiSJMFmsyVMU4s/XygUQiQSQbhtHSQA6ugA+g6/BMX28k0BURRhMBggSRIk0QwrAHjm4RkbgVRWEXtckvS737mOViT/O3k/RVGgKApUVY2tERONQpZlyLKMaDQKRVH07yORSML+oijCaDTCYDDAaDTC4o5VMbNuPR9ro97YNu3rULcmt3yZpaZGIwjd/e8AAOOrX79gql+2IiJnisVcA4fDgdnZ2bR5jOXl5QkjNMUu9JGqAECqx1wuF7q7u+FyuRY97a1QR48exZe//GWYzWb867/+K7q6ulakHUTxGMzQK5ogCLjxxhtxww034IEHHsCNN96Ia665Bh/4wAdSduKWytjYGPx+P7Zs2aK3K58/vku5aN0rUa6djb/97W/YvHlzTtMkkq+/6GqA5T2fRPCb/4Lwr/8bhm0XwLBhW8J2S5UTYLzh1lgw85dHYbr5fRCd2YtJ5CN+OhXKyuBtaIU60o/msBeGLWfp2ymKgkgkogcTarkTwvwMAgNuyE3tkGU5IfDI5TMcCARSrnwen3OgfYmiCFEU9YBJG02SJOnlIOv0c+n4ThyCAkDauh22F54BgEVVMSu2yO9/A2WgG0JZBcy3vH/B8/y9sHiVlZWYn5/PWJRFG6Hp7+9Ha2trypsl2cosZ1tjS9sm3XFEUUR5eTnGxsbQ0NCQ8TUV24kTJ/DlL38ZgiDg85//PNauXbus5yfKhMEMnRFEUcQb3vAG3HTTTfjNb36DG264ATfccAPe9773Lfl8X1mW0d/fD6fTqZdhTTdykO4OnaIoRbvDX4ojLUvh5MmTesJ2vrTraLz4tYi88DTkZ3Yj8K1/ge0rP4VoX9rV2AFAWn8WxLWboZw8jMjvfwPzze8r+jniP4/Smi2IjvRDPnUY0jkX6Z8hURRhNpv1HDBffROU+Rk4o34YT3e28g3EbTYbOjszT50rFtXvhdJ9FFBViOvPgvDTu6CiuOvLLIYyPYHQL78PADDd8gEIZZUr26BXKIfDgcHBzNMjBUFARUUFotEohoaG0NzcnPB8ts94sYqzVFdXY3BwELW1tTAYlr4Ld+rUKXz5y1+GLMv47Gc/i/XrV8eIJVE8lmamM4ooinjzm9+M3bt3o76+Htdffz3uuusuBIPBJTvn0FAsITpbKeZ0d+2KGYAwkImZmZnB0NBQwYuWJqwD8Z5PQaipgzo6hPCP/2+xmpjxnIIgwHTD2wCoiPzh11CDgaKfL74krbTu9HozJw9l/AyJrthaM2pcRbPVPHIgH30RUBUIDc2A3wt1ZhKK0Qxh3baM+y3XAqChe78L+L0QuzbBeOWNizrWSlrNnwEgNuqS6zou1dXVMBgMGBsbW+JWpaYFMKkqsBVTT08P3vOe9+ALX/gCPvnJT+InP/kJAxlatRjM0BlJkiTcfPPN2L17N6qqqnDdddfhO9/5DkKh4q6sHolEMDU1BVEUFyRg56qQPINXkmIHYNFoFPv27cN5551X0JoQyQRHOSwf/gIgAJHHf4fIs48XqaWZ22I473IIriaoc7OIPPHIkpxTI63bCgCQTx6BmmHdDVFfOLM0KppFj+4DABg27UT0xT2AIEDdcBa8WW5uZPrcFGuaoXzsAKJPPgwAsLzr4xDSrH203Ar5XbOabqKkar/JZEI4HM75GPX19QiHwwvWp8nnnItRXV2NsbGxJVks1+1244477sDnPvc5fPSjH8X//M//YNOmTUU/D1ExcZoZndEkScLf/d3f4a1vfSvuvfdeXHPNNXjrW9+Kd77znXqi/mL09fXBbrcv2QrtmtXUWSi2YncE9u7di3Xr1i3ImcpWNCATw+YdMN34doQf+CmCP7gT0rotEKtdRWtzyhXeJQmm625G6EffQPiR+2C8+g0L1kVJd6ycgrT4pPnWLsBsAXzzkAfdUOqbEQ6HEY1G9SpokUgEBsmMMgCenpPoPXoUqqrGcmlOT5WMT9pP/r9mdnYWzz77rJ4To7Ul/guAni+j5cwYDIaEPBktyT/5Kz5/Rj68HwAgbT4HkT8/DKiA8ZyLMOPxJJS3zkeun5lMBUBUWUbw7q8DAIxX3qgHk6tBsX/XCIJQtGm0uZ4vlXwT6pubm+F2u2E0GmG32zO2v9ivraysTM/D1HJ5Fqu/vx933nknZmZm8JnPfAZnnXVW9p2IVgkGM0SIDd3fdtttuOWWW/A///M/eO1rX4tbb70V73jHO/Q8l3wFg0H4fD4IgoC6urqCjrEUOS5nct5MX18fDAZDyvVkFntNTG95H6IHnofSewzB7/4rrP/8zZyCi1Tt0Dr32dpkvOIGhH75Q6ijA4i+8BSM512W9fha8BAMBvWvcDisl2nW/i3LckKlrHVV9XCMuHH0sd9ifsuFCcGC9r1YE8s/Ms5NoLy8XK9iFh94pPvSlJeX45xzztGDHwAJ/0/1WCQS0auZhUIhvSCB9jriv7SOsxgK4KzuIxCgYt+MHxuO7IcIBYPORgydOAFVVWE2m2EymWCxWGAymYpaQSrTexvZ/VsovccBRwVMt34g5b4rNRpb9MVAlzGQyUQURb08cy4EQUBbWxt6e3vR1NQUK5aRRfy1S3cdc72+drsdMzMz+uezUIODg/jKV76C8fFxfOYzn8E555xT8LGIVgqDGaI4RqMR73znO/G2t70NP/7xj/Ga17wGb3/72/H2t78972TLnp4e1NXVYWhoqOBRnuVY2+JM4fF40N3djcsuy97hL4RgNMHykS/B/+nbIB/Yg8hjv4TpupsXbJetJHemTs6Cc1rtMF19E8L3/wSRh38G9ewL4fV64fP54Pf7EQgE9OAkefqTyWTSO0Jmsxk2mw3V1dV6FbPkz3uwbz8iD7mxVozAsmtXyrYrznL4AEjTk2isr4MgGfLu/IqiuKjOWa6iLzyFgKpCqG/B2fU1CCsyVFcjyrvWY7KnBx6PB3Nzc/qimZFIRL+GqqrCYDDAarXq5a0tFgvsdjtsNtuigh5lbhqhX3wPEASYb34fhHLngm1Wclppob8/0gVguUz1XI7fWTabDV6vF5WVlTnvI4oiWltb9ZLN2W58Jee9pSv6kstoVU1NDUZHR1FZWVnQOkjDw8P4yle+guHhYXz605/Gzp0789qfaDVhMEOUgtFoxHve8x7cdttt+NGPfoSrr74at99+O2699dacghqv1wtVVREMBlFWVnbGBhCrhaqq2Lt3L3bs2JFylftkhd75lprbYX77RxD64dcQ+tm3IG3ZAaktsYRputXGs7UnGo0iEAjogYrP50MwGES0ohVbRQk4+iKO/e7XQOcG2Gw22O12VFdX6x3txY4qSOu2IYJ7IZ84nL6dVbWAwQhEI1AnxyCczqHJJtUd63TXv1idWz1fZvNOqIeeBwCYztmF8oYGGI1GSJIEp3NhIKEJh8MJ78PExAT6+voQDAYTAlaTyQSbzQar1QqHw4GysrKM+XPh+74L+OYgtq6D8arXv2J+dxQagCUvcpt8zGJdH5vNBp/Pl1cwIwgCjEYjmpub0d/fj46ODn00c7G5jtn2NxgMCIVC+t+ZXKtyjo6O4qtf/Sr6+vrwT//0Tzj//NVRuY9oMRjMEGVgMpnwvve9D7fffjvuvvtuvOY1r8G73vUu3HzzzRk7xW63G/X19RgdHUVtbW3Gc8R34gqxHFNOFttpWI67q5muw+HDh9HU1JRzHsRirqfx6jciuv8ZyHufQfA/Pw/bnT+CYDKnbXO8cDiM+fl5eDwe/SsajWJ8fBzV1dWoqKjQAxWn06mPCgR69yP65CPY2H8I1jfdWnDbM5HWxCqaKf2noAb9ECwL12kSRBGiqwHKcD+U8SG9IEA2yXes8+3kFfL5is+XCf3yB7Hvz4qtL1NWVobx8fGMwYw2spWp86tN5/N6vQgEApiZmUFfX19CoRGbzQaHwwG73Y7yyRFIf3oAgADzez4BQTqz/0RnCmS054vFZrMhEMhcFTC5Ldrn1GKxoK6uDn19fWhvb886lSybXHPazGazXrjAbDZnvGExPj6Or33tazh16hT+6Z/+CRdeeGHe7SJarc7s35REOTKbzfjgBz+Id73rXfj+97+Pq6++Gu9973vxlre8ZcEfkOnpaT2XIBwOw2w2Z/yjlmo6QT5/BHP9w7eYDno+f5AXk0i/mKAn3eubnJzEzMwMLrnkkoKOmy9BEGB532fh/+TboPSfQujn34Hlto/pz0ej0YSAxev16p1bSZLgcDjgcDhQX1+PdevWwWKxYGhoSJ8ClorphlsRffIRRPc8DmVsGGJdY9Ffl1hTB6HKBXV6HHL3URg270j9Xtc3AcP9UMaH9eux1PI9h+rzQOk9Ftu3pgHqyCBgMMCwZQcAJHQSF0MURT3gTEVRFHi9XszNzcE7Pw/Lj/4dVgDT63fAPT4P89xzKC8vR0VFhR68nkky/c4q9g0Si8WC+fn5jNtkOp/D4UAkEsHAwABaW1uzbr8Y2mt3OBz6Yp9+vz/liN/k5CS+/vWv4+jRo/jUpz6Fiy++eEnaRLSSGMwQ5cFiseAjH/kI3vve9+K//uu/cPXVV+N973sf3vjGN+pBzeDgIJqamhKClEx3GDM9lssf7Fy3WW75djaWYvQmGo3iwIED2JUmx2OpiM4amO74Z4S+/glEHroPfWV1GKtuhqqqkCQJNpsNZWVlqK2tRWdnZ9ZOaqY706qqQmpbC+ms8yEf2IPwY/fBcvvHl+JlQVq7BdE9j0M+eQSGzTtStkt0NUMGoI6t3vLM8tEDgKJAqG+B0n8KEABp/TYItpc7g0ajEZFIJGUeRLE+q9qK7uXl5Qj/6QGERvsAqwMt//gltFXVwuv1wuPxYHZ2FgMDA3rQa7VaUVZWhsrKSjidzpxzjFK1u1QLghS7zbmMzCRLvnZOpxPhcBijo6MFLcabK+2cZWVlGBwcRHV1tV5RUPu8Tk1N4T/+4z/w0ksv4ROf+AS++tWvLll7iFYagxmiAlitVnzsYx/DHXfcge9+97u4+uqr8cEPfhCXXXaZPtzv8/kSOqmFTD3INZ9iqRTS0YkP4ArZr5j27dunj24UW/y1CQaDmJmZwczMDObn5/VOZ8c5l8C5/yk0PPI/6Pz6T2F0Vud13OTHMzFddwsCLz6HyJ9+B/Ob3gvBUZySrfG0YEY5eTBtW7WFM5XR1RvMRI+8ACCWLyMfeA4AIG1LzB2w2+3weDyoqqpasH+xk9ZVzyzC934HAGB+83shVsWmpmqjdA0NDQnbe71e/fPW29uLSCQCINYhr6ysREVFBaqqqhbk9+V6M6XUFfJ7y2az5T0alyr/ra6uDoODg5ienk752Skmg8GQUHVQm9L4jW98A3v37sUnPvEJfPnLX35FvsdE8RjMEC2C3W7HJz7xCbz//e/Ht7/9bXzta1/DBz7wAbzuda+Dz+eD3W7PuP9qvyu63G0rZv7P0FCsM52qDPNi+P1+TExMYGpqSi/0IEkSqqqqUF5ejvb2dj2IVc8/D/5/ug3KcB+id38dho/fmfWa5tPhjL9W0tkXQmxdA2WgG+E/3g/zTe9YsP9ir624LpY3I588lH6kUV84c3hR51pKWr6MuHEbQnf/OwDAcE5iDkFZWRlGR0cL6pDm+3MT+vn3oM7NQGztgvGaN2fdXgty4mlT1mZnZzEyMoJjx47p5aWdTieqq6tRVVVV1PLSq1Uhv7ckSYIsy0U5Z1NTE3p7e2G1WnNOzC+U2WxGMBhEIBDAd7/7Xezbtw+f+tSn8KUvfWlV/20hKiYGM0RF4HA48KEPfQiXXXYZHn74Ybz+9a/H61//erztbW9bsG1ysjO9rFiBTCgUwrFjxxZdhjkajWJqagpTU1OYnp6GLMswmUyoqqpCa2tr1s6hYLHC8vdfgv9z70Z0z+OIPvkIjJdfv6g2pT2XIMB0w60IfudfEXnsVzBddwsEY6wkeLGuq9SxAZAMUGcmoU6MQnA1LNhGrNeCmdU5MqN656G4jwNArIhBwAehogpi+7qE7Uwmkz7iseAYRbwJIfceQ+SP98dKMb/z4xAMha1rJUmSPmVNy9kAYsH35OQkBgcHceTIEaiqCovFgpqaGjidTlRWVq5YgFMKxUuAhSMwuWzf2toKt9uNjo6OlMViCnntqfYJhUL42te+hv379+MDH/gA/vmf/7ngBV+JShWDGaIiGRgYQHt7Oz7xiU/gjjvuwL/927/hjW98Iz74wQ/iqquuYuCyjPbu3YstW7bkvTbQ7OysHrz4fD4YjUZUVlaiuroaa9asKWi9IGnNRpje8h6E7/svBP/73yFtOBtifXPex8ml42O4+DUQ7vsu1KlxRJ/9I4yXXpv3eTJ1sgSLNTb603sM8qnDEFMFM7WnH/PMQfXOL8l0t8WQj+4HFBlCQxuUU0cAFZC2nptygdN0eTPF+llWFQXBu/8DUBQYLroKhq3nFn6sNO+ZzWZDa2trQoAzPz+vT1Hzer0AYjdkamtr4XK58p6WmW3tpHzbnG7bQq57Md4rVVXznh5sMBjQ0NCg/11Ifr6QIC5+H4/Hg+9973t44okncNttt+Fzn/ucftxQKASzOXUFRaJXIgYzREWgDfNrc9vLy8txxx13wOl04nvf+x6+973v4UMf+hCuuOIKAKkXTFuOu5Sa1T69bTEGBgZgNptRV1eXcTtFUTA+Po7R0VHMz89DVVU4HA7U1NRg06ZNGdcCySTVtTXd+A7I+5+DfOxFBP7zC7D963/lVXZXmxOfjWA0wfiaNyN833cR/t3PYLjkmqJ3MKV1W6D0HoV88iUYL3r1wjZY7RAqq6DOTkMZH4Z0OphJVdZ2JT6D0SP7AAgwbN6B6IE9gLBwipkmU95MMUSefBTK8QOAxQrz2z+yJOdIRRvBaWtrAxD7WZifn8fExAT279+PYDAIu92Ompoa1NfXF1ygopiKeY74tYxyHSnP57Or/QzZ7Xb4/f4FBQFy/T2f6jxerxc/+MEP8MQTT+B973sfPvShD2Fqaiphm2AwyGCGziiv/MmzRMtgYGAgYT0ZrZJZVVUVPv3pT+OHP/whnn32WbzpTW/Ck08+qd/pi7ecFcdeqYFMKBTC8ePHcdZZZy14TgteDh06hL/85S946qmnMD4+joaGBlx88cW47LLLsGPHDrS1tRUcyABpcl4kCZa//wJgc0A5+RLCv/3xgm2yvf+KouR0ftPVrwfMVih9JyEffD6nffIhrdsCqIB84kjabYTaRkAFlLGX82byKde9lJ9PRcuX6Vinl2eWtp6XctuysjJ95KLYVJ8H4Z99CwBgesO7IdZkDr7zOnaev0tEUURlZSXWrl2LCy+8EFdccQU2bdoEVVXx0ksv4cknn8Szzz6L7u7urOWLl7qthe4TL12REkmSEtYAyrZ/Lmpra/X1o/IVfx6/34///M//xN/93d9hzZo1uP/++3HttdfCbDYjGo0mbKutb0R0puDIDNEihcNhzM7OYu3atfqdtEgkApPJpP/RdTqd+OxnP4upqSncdddd+Pa3v41/+Id/SKj5/0oeLVkue/fuxbZt22AwGKAoCiYnJzE+Po7p6WmoqoqKigrU1dVhw4YNeU9BWyzR1QjLez6J4H9+HuFf/xCGs86DtG6r/ny2zn2uHTihrBLGK65D5Pe/Rvjh/4lNoSrwc5XqvNKaLYAgQOk9BjUS1vNy4ol1TVBOHoJaYN7MUgX2qnce8ukABqeTvcX2dRCdNSm3z5Q3s1ihX/0A6uwUhMY2mK6/uajHzjZqkMvnQSsy0NXVBeDlwhfHjh2Dz+eDyWRCTU0NGhoaUF5e+FTClZo6lorZbC5oila2a9rc3Ize3l5YLJa8p6oGAgH893//N37/+9/jXe96F+6///6EHCdRFBfc6BAEQX8d/JtCZwIGM0SLpC1oGC8SiaTsLFdXV+MLX/gCJiYm8K1vfQt33XUXPvKRj2DXrl2vmD86KxWU9fX1IRqNYnJyUq/ktJLBSyqGi18LwwvPIPrX3Qjc9XnYv/ZTCNbEincpyx3nOM1MY7r+FkR2/wbyvueg9HdDaltTUHtTnVNoaAHKKgDPLJT+U5C6Ni3YRqyL5QQpq2ytGfnIfkBVITa1Qz4VG1kynH1Bxn2MRiPC4XBCJ3Sxn3G57yQij/0KUAHLuz6eMiBcKqlGyHLJCbHZbGhra9OnpgWDQYyPj+PYsWPwer0oKytDfX09GhoaVsXPWrxcbwaYTCYEg8G8g7NsnwVRFNHc3IyBgQF0dHTowUimax4MBnHPPffgkUcewe23344HHngg7e+B+GAmfgqdtmgz0Ssdp5kRLYJW7crpdAJ4+Y9aOBxOudiepra2Fl/84hdx11134dFHH8Utt9yCPXv2LEubl9pyBjKKomBoaAhPP/00fvWrX8FoNKKsrAwXXXQRLrvsMpx99tlF6VwV6zUJggDLez8FobYO6uggQj/+Zk7nyjefSqxvgeG8ywEBiDzy88U0OWVbpLWbAAiQTxxKff66RgCrr6JZ9MheAID4/7N33vFRlPkff8/M1vQeSCAJvRdBmoiK3qmncgoWFBt2zy7qnXqnnnf+zvMU+9mxV1TAdpY7RQQFUZAapAQSSnpvW2fm98dml02yu9mWZIF5v17oZneeMrOz8zzf5/l+P9+RE5A3uX5vHfPLdCQ+Pr6Tq1kk94OqqtheXgiKjG7aiejG+47X6SnCDd43mUzk5eUxefJkTjzxRIYMGUJzczPff/893333HYWFhdTX13dDj0Mn2N+OTqfD6XR2Sx+MRiOZmZns37/f856va26z2XjppZc477zzSE9PZ9myZe2SMvtMVOu1U+P9eTAucxoahwOaMaOhEQEVFRXEx8d38sFWFCUoudOsrCz+7//+j8cff5xly5Zx4YUX8tNP0Y9zOJxobW1l586drFq1ipUrV9LQ0IDVauXiiy9m2rRp9O/fP+orw9F0exISkjBddx8IAo6vl+FYs7zLtgRBCDpmxo3hjHkAOFZ+jlJbFX6HfSANHtMWN+PbmPHkmqnY7/Pz3kIuXA+AmJmDWl8DJjPS8M7xVd4kJCTQ0tIStT44v//K1Q+DAeMlNwM9Gy/XXaSkpDBixAiOP/54jjnmGJKTk9m5cyfffPMNa9euZe/evT6TUsbSuev1+qgYM/7OKSkpCYPBQHV1dafP7HY7r7zyCueccw4JCQksWbKEc8891yPrHI4BrShKyIlANTQORTRjRkMjTJxOJxUVFWRlZXne817lDCWTe3Z2Ng8++CCPPPIIixcv5qKLLmL9+vXd1/kI6ckJiKIoVFRUsH79epYvX87GjRsxGAxMnjyZ448/npSUFJKSkrpUL4sldKOPxjDrQlQVbC/8XztjIxo7MwDS8HEIQ8aAw4H9i/cj7nO7uoeMBgHkXZt9fi5muYwZtaoCVe6ele5QUZsaUIp3Aiqq1WWcSKOO7tLFy2g0Rm1CqLa2YHvzKQAMsy9HzHLtYB0uLqZudDodubm5TJo0iRNPPJHhw4djsVhYu3YtK1asYPv27bS2tgK+z723DJxAOzOh9CnQOfXp04fm5maPgexwOHjttdc4++yz0el0LF26lPPPPz+oBZlg3B0tFkvQ/dbQOFSJLcdWDY1DiIaGBiRJ8pkQLVCMQ6DP+vbty8MPP8z+/ft57LHHeOKJJ1iwYIFPda5g8TasojVJ6M7Jl9t/v6ysjH379mGxWEhNTaVfv35MmDCh3bFOp5Nt27YxY8YMn/XE4iTR3S/D+dfi3PwTyp7tWJ/9O+a7HveZ6wRc90w42cmNsy7E+uidOP63FOOc+a4kkVFAGuyKk1HLD6A01CImt5cuFtIyQacHpwO1uhKhze2sN3Fu29AWLzMApW1Hqat4Gfd35c4O7+u3Hgq2JYtQayoR+uRi+P2FEdXlj1i8791S0MOGDcPpdFJaWsrGjRux2+1kZGR0UhDsif77i03zZ7hGM/Fm//792blzJ2vXruX999/n3HPPZcmSJQFdk/3t2PpSxvTGvTsTTo4sDY1DBc2Y0dAIA6fTSWVlpSdWpiOiKAbMHt4V/fr1Y+HChezbt4+FCxfS0NDAggULGDNmTJdl/bUXS+4cvlAUhdLSUvbu3YvNZiMzM5ORI0cGDMbduHEjQ4YM8TlQ98aELpiJpMclUW/AdMP9tN51KfKGNTi+WIzhNN+qVuG4mQHoJh+PkJ2LWnEAx7efYTj13JDr8NmfhCTEnAKU0mKUnYWIRx/b/nNRRMzKQSktQanc74mhiYRIJumqqiJvXYeKijh0LM5Vn4MKurG+JZnduNuLi4ujubk5oszq8v5iHJ+64pdMl96GYOiewOxYM2Q6otPpPEk83TFvmzdvxmKxkJWVRb9+/UhJSen2fvi6Tnq93q9LYbSMRKfTyfvvv8+bb77JzJkz+fDDD6NuaHTsq9Vq1YwZjcMazc1MQyMMrFarR8En3BWzYOjfvz+PP/44999/Py+++CKXX345hYX+83tEk56YFCmKQllZGWvWrGHFihXU19czevRoZs6cyejRowMaMlVVVVgslnaZzXubUK+ZlDfQkyzR9ubTyHuL/NYbzr0kSJLHQLJ/9g5qGLs7/hCHjAZA3unb1UzIdueaCSwC4Ot30jFBYcf3vD8L5poLgoCzcB2CCiQkgtOJ0CcXMSe/y7IQedyMqqrYXnkEZCfSxGPRdTD+jlREUaR///5MmzaNE044gfT0dHbs2MHy5cvZsGEDtbW1Act73zfRWKzR6XR+d0AjfR7KsszixYs566yzaGlpYcmSJVx00UU0NTVFVK+vvnVMBKooSrcJG2hoxALazoyGRogoikJTUxNmszngBCuclXR/5OXl8eSTT7Jnzx4eeeQR7HY7CxYsYMSIEVFroyPRmBz4moS7Y2D27dtHS0tLUDswvvq2adMmjjnmmJDKxNKqtbs/+lPOwfnLKuT1q7E+eS9xD77SKY4jHGPGU//MM1w5Tcr34/x5JfopJ4RVT0ekYaNwrvgUeddWn+XE7H7IAqhdiAB0FTMRjfw7alM9askuEARociUv1I2b6mmrq/vCbDZTXl7eZTv+cP64HHnTWtAbMM2/Nex6DmdEUaRv37707dsXRVGoqqqiqKiIjRs3kpmZSUFBQadktu7vLVq/7Wg/t8FlxCxdupTXX3+d008/nQ8++ACTyQS4YiWLiopITEzs9p0Tm80Wc5LZGhrRQruzNTRCxGq1Ultb69fFTBAEn4nMosGAAQP497//TVFREQsXLsTpdHL77bczdOjQqLcVDh0nFd4TzdraWvbs2UNjYyOZmZkMHz487GR727ZtIy8vD7PZHHSZWDJkoH0WctM1f6H19otQSnZie+dZTG0qV25CzTPTbmXWHI/ht2dhX/Iajk/eCtmY8XfdpCEul0d5VyGqonSK93GLACjlZSG11x04t208mF9m+wYApDZjJtidnY6xZ8HeT6q1FdvrjwFg+P3FiH36h3cS3UQ0Y+nCwV/sSnZ2NtnZ2Z7d282bN2O32+nXrx/5+fntJubR+m1LkhTxc9t7Meujjz7ilVde4dRTT+W9997r9LwSBIH+/fuzf/9+Bg4cGFG7/nB/vw6HI2iVTQ2NQw3trtbQCBGHw4HFYvFIMvuaCJhMpm6VxBw0aBDPPPMMd9xxBwsXLuQPf/gDRUW+XZR6ko6TCrvdzvbt2/nmm2/YuXMn+fn5QbmQBZpctbS0UFFRweDB4SWCjEXEtExMf/gLAI5P3sa5eW27z0OdcHY8Vn/KeaDXI2/fiLzDt1tYqIj9B4LRDK3NKAeKO33ukWeuKo1Ke5EgF/4MgDhgOGr5fpB06EZPDKkOs9nscTULZfJsX/oaamUFQmYfDGddElKbPUFvGDLB7ryBy7DJzc1l2rRpTJvmysmzatUqfvjhB8rKomsoR2MRSlVVPvroI84880z279/Pu+++y3XXXed34cVoNJKYmEhFRUXIbQmCgNPpbCdM4Wsn3I0m06xxuKIZMxoaIWC322lubiY+Pt5n1mz3QCJJUtg+yqFMlIYMGcLzzz/PzTffzEMPPcT1119PcXFxWO12JJJJTllZGatXr2bNmjWYTCaOO+44pkyZQkZGRlDlA12DX375hXHjxsXcTkuk6CbNQP+b2aDKWJ/+G2pTveczt5pWuIjpWeiOPRUA+ydvR9pVAARJ51E1U3zEzYh9YifXjLylTea8LeheGjYWIS4hQInOxMfHhxw3o5Tuxf7xmyCoGC+5FcF0cEJ7uN2/oRDuuRsMBgYNGsQJJ5zA2LFjqays5Ouvv2b9+vVRSdAZyS6Vqqp89tlnzJ49mz179vDOO+9w4403EhfXtYJgZmYmLS0tPmWUA10rVVU7JWgOFD+jGTMahyuam5mGRgjYbDZqamrIzs72mw+k42vvATIY95RwBtPhw4fzwgsvUFhYyAMPPIDZbOaOO+6IKDi+Yz+76ntzczO7d++moqKC7OxsxowZ08nHPVL279+P2WwmLS2t64NjHF/X03jpzTi3/oxatg/rCw9hWvAPj9uiv/siWJcnw6x5OL/9FOfa5SgVBxDbdk4iQRoyCnnrOuQdhehPPLPdZ2JmX9eL5kbU5kaEhPBcCiNFbapH2bvL9brWtfotjZsScj3x8fE+kx36bVdVsb62EJx2pPFT0XVw74t1dcFg6a1YtISEBI9kfWVlJTt27KClpYV+/foxYMCAsOJDQnXnBNf5f/nllzz33HPMmDGDN998k8TExJDb7t+/PyUlJQwaNMivq25HBEHAZrNhNPpWxvO12KbJNGscjmjGjIZGkDidTpxOZ9CDh16v7zRwRGPQDzR5GDlyJC+99BJbtmzhr3/9K0lJSdx222307x+5n76vNhVFYd++fZSUlKDX68nPz2fs2LFh9z8Qsiyzfft2jjvuuJDLxgre5+7TGDbFYb7pb7T+5Sqca77G+d1/0B9/ekD3l2CvpZQ3GGn8FOQNP2L/zzuYLrs94vMIpGgmmOMRUtJR6qpRqkqResmYOZhfpgB5+ybgYPB/sKiqGrILkvzTSuT1q0GnxzT/9m757fd2vIu7D256y7DJysoiKysLp9NJSUkJK1euJCkpiSFDhoQUlxfKooGqqvzvf//j2WefZdq0abz++uthxwCCa7xIT0+nvLycvn37BlXGbZwEs/sDWs4ZjcMXzc1MQyNIbDYbDQ0NQeeaMBqNUcm+HMhtwB+jR4/m5ZdfZv78+dxzzz0sWLCAAwcCS+R609UEyWq1smXLFpYvX05raytTp05l2rRp5OR0nU8k3MnO5s2bGTJkiN/EcoHkfWOFYPokDR6F4ZwrAbAuegSlfH9YK8a+MJx+IaDi+OZj1KaGsOtxn4c0eBQAyv7dqK2dXbCErBwEQCkP/t6LNvJWV7yMkJMPllaE5DTEAcNCqsN9viaTKajftGqzYn3tUQAMZ8xDzA1OAjrYfnjaibHdHe/g8p7oW8c2dDodgwYNYubMmfTv358tW7bw3XffsW/fvojb8lZO++abbzjnnHNYt24dL7/8MnfccUcnQyac809NTcXhcNDc3BywvPdngRbXfI0dsix3iziNhkZvohkzGhpBoKoqTqeTuro6vypm0H7wMJvNWK3WoOqO5PNAjB8/nldffZWLLrqIu+66izvuuCOioNna2lrWrFnD2rVrSU5O5qSTTmLEiBGdVvqiPZFpbGyksbGxndtcbxsv3TlZM8y+FGnEeLC0YH36flTZGZX2pHFTEPOGgNWK/X8fRVyfmJaJkNEHFAV5V+f8R2JmLqqqRhw3E47rjxt563pQFQQBUFWkMZPaKa+FUnd8fDzNzc1dHmf/+E3UylKE9CwMcy4Lqe/RItYD+6NBoDaysrI45phjmDJlCg0NDXz99dcUFhYGfCZ3ZUCsWLGCc889lzVr1vDSSy9x5513+k3wGe755+bmUl5e3qV7mRuHwxHSTot7N0dD43BCM2Y0NILAbrcjyzKqqvrdGehIXFxcUAHDPTHoT5gwgddff525c+dyxx13cOeddwZUz/Huk6Io7N27lxUrVrBr1y6GDx/Occcd1851rbsNiw0bNnj844Nto7snc935vQmShOn6v4I5Dnn7RuxLX49OvYKAYdY8ABxfvIfqiHxSIw0ZDajIu7Z0+kzMzkVAQK2ITHUqmGvtayKtNtajlOwCQUQuc+0O6Y6aFnLdbuLj47vcmVEqDmBf9hqoYLz4ZgRzfND1R5NY3Jn0RbR/px3rMxqNnkS8CQkJrF27ltWrV/uMf/LnJrdq1Srmzp3Ld999x/PPP8/dd98dcFEr3L6CS+wjKyuL/fu7XgCw2Wwhu4y542w0NA4nNGNGQyMI7HY7LS0tQfsmg2tQ6o4kbJFw9NFH8+abbzJnzhxuvfVW7r77br9Gjd1up7CwkOXLl9Pc3My0adOYPHmyz5XI7pw47d+/n/j4+KDd+2KVUOMJxOwcTFf+EQD7+y+i27crKv3QTT8ZIS0TtbYK5w//jbg+lzEjoOz0Ycz0yQEBlKrudzPzdW2d2za4PsvJR227ftKYyWG3odfrcTgcgP9JuO31x8FuQxo9Ed0xvwm7rZ6it40edw6faNbnC1EUycvL47jjjmPEiBHs2bOHFStWtHO/VRSlXfkffviB888/n//9738888wz3HPPPaSnpwds331fBJu/yBdJSUmIokhjY2PA8k1NTSGLDbhVOLXdGY3DCc2Y0dDoAqfTiaIoNDU1hRzgGR8fT1NTU0hlesI9ZPLkybz99tvMmjWLm2++mXvvvZeqqirAlcdl3bp1/PDDDyQkJDBz5kxGjhzZI0GjvnIkbN++vUtRgUOBcIK1dTN+h+6Y34Iik/je06iW0KSBffZDb0B/yrmAS6Y50vtNGuKKm5F3FXbeocvuXXlmd7yMmJHt+v+AoYipwcmD+8Mtk+3TeFr/A861K0CUMF5+W68bCsEQC3E3Pd2HlJQUJk2axJQpU6iqqmL58uXs3bsXcP1O16xZwwUXXMDnn3/Ok08+yX333edXVt5fTGOk55STk0NlZaXPxTB3Gy0tLWErRmrGjMbhhKZmpqHRBQ6HA1VVsVgsQanMeE9ak5OTqaysDGlXIdoToEA7Au5EdKtWreKaa64hKyuLWbNmMWnSJLKysqLaj2Do2M9ff/2VAQMGBO3aF0m7sTCpg4N98QSdX/lHWrZvQldVju21JzFde1fEbRh+exb2pa+glOxA3rQWXRhSxW7EAcNAp0Otr0GtLEPIPigCIWblAipqVQWq7ESQenbIkbe68suobTmfdOOnBTo8KNzJMzsFfDvsWF9ZCID+9POQ8kJP6hpL92FvEcoOZqTqaSaTifHjx2O329m1axeLFy/mk08+4ZhjjuGxxx6jT58+QfUh2rjl2DMyMqioqOg07rjbdDqdXUpQ+7un3EIA3qINGhqHKtpdrKHRBQ6HA6fTiSiKPvPIdMR74DAajb2+AtbVBKmxsRGDwcCtt97K6aefziuvvMILL7xAbW1tu+N6epLV2tpKRUUFAwcO7Pa2YmkC6Z2TCEBITMZ0/b2oCDi+XorjxxURtyEkpqCfOQsQsH/6VmR1GU2IBS51MLmDq5mQlgmSHmQnanVlRO2EitJQ58kvo+zfA4AUoiSzL+Lj42ltbe30vv2Tt1HL9yGkZmA856qw6vZ1H8bSvdkThGKcRGvhZ8uWLTz44IOUlJQwf/58fvOb31BXVxd24uNIcX/nKSkpWK1WnzEura2tmM3mTu/7q8sb95igxc5oHC5oxoyGRgDcLmaNjY0BpTcDTTiClXOF4AOdQx3EfR3f2NjImjVr2Lx5M4MHD2bGjBnMmjWL999/n+nTp3PVVVfxj3/8w5NZu6ddZjZu3Mjo0aN7tM1YwNe9pBszCctxZwBge+EfKLVVnY4J9fsxnHa+KzB+wxrkvUXhdbaNg65m7fPNCKKI2Kd3XM1kd7xMn1xorANzHNKwyN0V4+LiOhkzSlU59iWvAGC86AaEuOgli411V7VDWUVw48aNXHrppbz99ts89NBD3HPPPUycOJGZM2diMplYuXIlW7Zs6dUFqZycHEpLSzu9X1NTE7YIgdt1zR3/paFxqKMZMxoaAXCvXHUVaBloQE9OTqauri6o9oIZqCN1Ramvr2f16tVs3bqV4cOHM336dNLS0trVP3PmTD744AMmT57M5ZdfzkMPPURDQ/h5SULtb3V1NaqqkpmZGXabvUWkkzt/5S2nno9YMBS1sQ7rc3/vdE1DvcZin37oJh8PgP3Tt8PrbBvS0LbkmTu2dvpMyO4HgFLZs7lmPPllklwB29LIiQj6yOO+fLnl2F5/HGwWpOHj0M34XcRtHEr09G5SNIynjRs3ctlll/Hqq6/ywAMP8Mgjj5CTk4OiKOh0OkRRZMCAAcycOZOkpCS+//57Nm/eHLWdmlCuj9FoxGQyeRaV4GDyS5PJFFE/3PVoaBzqaMaMhkYA3IOX0+kMOwA+ISGB1tbWXlc1a2xsZNWqVRQWFjJixAimTZvmN0cCuCYNv/nNb/jwww8ZP3488+fP5+GHHw5Z0MBdVyhs2bKlkxRzrOFvZ667JnKi0Yj++vvAYET+ZQ2OL94Pun/+MMy6CADnd//xudsTLNLgUaCqKHt+7ST3LGXngApqkDszgTKwh4K8dR2oKrS68sLoxkfuYubug16v9yx0ODetxbnmGxBFjFfcEfM7KT1BrF6DwsJCrrjiChYtWsT999/PY4891k5i3u1O7E1eXh4zZ84kOTmZb7/9lp07d/p8loeyuBDq9cnOzqa6utrTbl1dHcnJySHX40tpTTNmNA4HNGNGQ8MP7sB/q9XqN8OyN4EGr9TU1KB3Z4KtM9hyVquVdevWsWnTJkaPHs0xxxwT0IjpWIcgCJxyyiksWbKEUaNGceGFF/Loo48GlTwwHPbu3Utqairx8b2TnyNYgomfiiaiKKL2zcN40Y0A2N58Cnnf7qD65w9p2BjEoWPB6cTxxeKAxwZybxSy+yEkp4HTibJne/vPsnJd8sxB5prx20YI11hpqEXZtxsEAaWsBADd2M4iB951BrsrCgdzSKkOO7aXHwFAf/LZSAVDg+5jbxKKfPDhwK+//spVV13lkVd+8skn2yXgdaMoCpIk+awjPz+fE088EaCd+pmbjjvm0by2oiiSmZlJeXk5AA0NDe1204PFpwJfmyu1hsahjGbMaGj4wZeLWaABKtBnqamp7dwEgiXcAdGd36awsJDVq1fTr18/jj322KCMGH9tC4LAaaedxkcffcSQIUO48MILeeKJJ6Jq1CiKws6dOxk1alTU6uxNorlL45YE1p96LtJRU8Fuw/rkvX4TXwbbtmHWhSAI2P+7FNXaObDdTSD3RkEQEN1xMx1FADL7ggpKRWe//0BthYp3GbnwF0BFyOgDsoyQnYuY03nyGu7k073b6vjPYpQDxQhJqRjnXhNyn6NJOIHzHcUmYoloGAM7duzg2muv5cknn+Suu+7i6aefpqCgwO/xbjczX6iqiiiKDBkyhOOPP57GxkaWL19OWdlBIz2SPndVNjk5GavVSn19PXq9PigVMn/B/96vVVXVYmc0Dnk0Y0ZDwweKonhWq7yNma4G/UCTPbPZ3G27GR3Zs2cPy5cvx2w2M3PmTLKzs30eF84kRhAEZs2axdKlS8nPz2fevHk8/fTTPhWeQmXnzp3k5eV1KTd6qBDt1Vl3fhPTtfcgJKagFO/A9u6zEbWtm3ScK0i+uRHHt5+F3T9psO+4GaFPv5ATZ4ZzX3qXkQvXA4InEF8XBRUzb4xGI86qMmwfvuT6+8LrEBKSOvWjJ4mk3VjcoYnkfIqKirjuuut49NFHWbBgAc8880xQqoh2u93vzoz3NdLpdIwePZpp06ZRWlrKd99910n9MVSCOd9+/fpRWFjYZeJON76+144usYIgaKpmGoc8mjGjoeED99a7L3eMcHyhBUEgIyODmpqa6Ha0A+Xl5SxfvhyLxcLxxx/PgAEDAh4fiZiAKIqcddZZLFu2jL59+3L++efz7LPPYrVaw6rPbrezf/9+Bg8OPT9HKMTiKnQwuHdmAMS0TIzX/hkAxydv49z8U9j1CpKE4fR5gEsIQG1rI+T+eRTN2u/MSG2JM2lqQG0OnNE8EtoZM1vXAaA01QOgGzet0zGREv/FO2BpRRwyGt0Jszzvh5IjRSO67Nmzh+uvv55//etf3HzzzTz33HMMHRq865/T6fTrUuzr+zKZTEycOJEJEyawY8cOVq9eHfKiTij3gSAI6HS6sJ+x/lAUxfNs0dA4FNGMGQ0NH7iDIq1WK2azOSrxEW4BgWgPROAK7l+5ciX79u1j2rRpjBw5st3uRrjuccEgiiJnn302S5cuJSMjg/POO48XX3wx5NW+LVu2MHz48G5fJY7FVWg3gfrmbcwA6Ccfj/6k2aCqWP99P2pT+Gpz+hNOh4Qk1IoDOH/6Lqw6pMEjQRBQK0tR6qo97wvmeIQU10qyUhm8q1mouK+dUl/jipcBqKsGSYc0emK7YyLFWbge0/pVIAiYrrgdIYzEg4H6EswEVzOGDlJSUsKNN97IP/7xD66//nqef/55hg0b5vPYQNfNZrOFtSuckJDA1KlTGTJkCD/++CPbtm0LOg4llHuyvLyckSNHUltb69f4CPe+0IQANA5lNGNGQ6MDiqJ4VMxaWlrayV9GOoHo06ePJ4gz2DoDDXaKorBp0yY2bNjAuHHjmDRpkk+5zmgICXSFJEmce+65LFmyhISEBM455xxefvnldoOkv/paW1tpamoiNzc3rH5Gk96cJAZqu6MxA2CcfzNCn/6oNZVYX/pX2H0XTHEYfjsHCF+mWYhPROzn2glUdha2/yzLnWsmfHnmYM/Nk18mLQsAafg4hLjoiUmoshPbIlfQv/OYU5EGjYxa3W46/ua7in04Utm7dy8333wzf/vb37jmmmt48cUXGTky8PcR6LoFUq0M5v7LyMhg5syZ6HQ6vv32Wyoro5co1maz4XA4SEhIIDs7u9M44iaYZM6+ymhxMxqHMpoxo6HRAZvN5hkQWltbiYuL83wW6QTCaDSi1+tpbDzobtNVnf4GoYqKCpYvX05ycjLHHXdcp6Se0SCc89Xr9VxwwQUsXboUk8nE2WefzauvvorD4fBb3+bNm2Mm6D/S77i7jCFfxoxgisN84/0gSjh/+C/OlZ+HXb/+1HNBp0fZvhF5+yafx3R1btKQMUDn5JliVg4QmghAR4L9XtwuZrStsEs+VMwiwfHlByh7d0JiMk2/PSfocrEc0yIIQlTa6KmFgAMHDnDrrbdy3333eaSWI02w657Q+zNmQrk+Q4YM4ZhjjmH37t2sXr06Krvx5eXl5OS4fkeJiYk4HA7sdnvQ17yrnUDvRTwNjUMNzZjR0OiAW5JZVdWAPtTehDKIu3dnwh34rVYra9asoaSkhBkzZpCfnx9WPd2FO6hUp9Mxb948lixZgiRJzJkzhzfffLPTCmBDQwMOh4OMjIxe6nF4+Mst010TT0mSfLquSENHYzj3KgCsix4Je/dDTMtEN+NUAOyf+N6d6ercxCGuVXF519Z210TMznXloQky10wguvrduI0Ztd7l6haN/DJulLpqbO89DwgYz78Gp9n3js+htpPift5FSji7AqFQVlbGHXfcwd13380ll1zCK6+8wtixY6NStyzLOJ1O9Hp9VOozmUxMnTqVQYMG8cMPP7Bz586w62ptbXUJf3jtumdnZ1NWVha1+0rbndE4lNGMGQ0NL2RZRlGUkAeIrla9vAdzSZJITU0NSwxg9+7dfP/99wwYMIDJkyeHncizu/E+X71ez8UXX8yHH36I0+lkzpw5vP32255VwM2bN4e0qhorsQI9nWfG186MG8PsS5GGj4fWZlf8TJjBvIYz5oGq4vzpW+SyfaH30bMzUwhehpeYneOKp6mKPGYmoNulO15GVcFmQ0hKRYxi7hfb2/+GlhaE/GHoT5rtUZgLpY9HIpFej/Lycu68807uuOMO5s6dy2uvvcZRRx0Vpd65EEXRI78cTbKysjjhhBNwOp0sX76c6urqrgt1oKKigj59+rR7z2w2A9GLwXQv3mloHIpoxoyGhhfulSlVVbHZbFExFny5cGRkZFBfXx+0gkxjYyPfffcdra2tAaWWYxmDwcD8+fP54IMPsFgszJ49m0WLFiEIQkT5b44U/O3MgEuRzHTDfWCOR962Afuy18NrI28Q0vhpICs4Pn+3fRtBXHex3wAwx4GlFeXAnoNls90xM5HvzARCLvwFBMElOCAISGOndBmcH6xx7Ny2AefyzxBQMF91B4IkYTabsVgs0eh6yMSCUR+NPgSqo6Kigj//+c8sWLCA2bNn8+abb3L00UdH3GY4fYmkLlEUGTFiBFOmTGH79u1s2LAhaIGAuro6TCaTz7GoT58+VFRUBN2nrn7DWgJNjUMVzZjR0PDCO1i9tbXVs/oVKR0HSUEQPG4CXVFYWMiGDRsYP348o0ePjvrKYbiEO/AbjUauuOIK3n//fbZt28Y//vEP3n//fY9hd6QaK10himLAiYaYnYvp8tsAsC9+AaWo0O+xgXAl0QTHN5+itkkbQ3DftyBJSINHACBvPxg3446ZUavKUeXAq79hixgIAvLW9aAerCMYF7Ng7jdVlrG98igIIJ34e6RhLtcms9kclfxK4RALv5No9MGXPHxVVRX33nsvN998M7NmzeLtt99mypQph5TSoa+64uLimD59OsnJyaxYsaLLRMoOh4Pa2tpOuzJujEYjoih2ugdDOY+OLrKaq5nGoUhszIo0NGIA70SZABaLpV3wvxtfSkNdDR6+Pk9MTERVVRobG31O4Jqbm1mxYgV6vb5TgP/hMJGpra3lggsu4IMPPqCqqoqzzjqLJUuWaPkOAtDVRF93/Onopp4EikzrE/eiWkOfaEtjJyPmDwGbBft/l4Zevi15prLzYPJMIS0LdHqQZdTqwCvJ4d5Xqqoib/0ZBKCxztWXsZPDqqsjjq+Xouz5FeITMc673vN+XFxcUDszsbCL0pHe7pOvOLOamhr++te/cv3113PKKafw7rvvMnXqVJ9luqM/3flc9e77gAEDmDJlCps2bWLbtm2djnMfe+DAAXJycgL2y9fujL/rFEwslybRrHEoohkzGhptOJ3Odg92q9UalMxxJIknc3Nzqays7LQrsXfvXn766SfGjRvHkCFDOrXd3QNvT7Bjxw5GjRqF2Wzmuuuu47333uPAgQOcddZZfPTRR1Fzd4jk+4k1gjGaTVf/CSE9C7VsL7bXnwyrDcMsVxJNxxfvozpCm9xIg91xMweTZwqi6KVoFr48cyCUuup2rm1iv4GIqZGLSqiN9djefR4A43lXI6YczL6u0+mCMr5j8bcaTp+i+Tvybr+2tpYHHniAa665hpNOOonFixczffr0qLXVEV/nYbPZohb874uOz6G4uDiOO+44RFFkxYoVNDU1eY4TBIHa2lpMJlOX3gF6vR6DwUBzc3NU+umdLFpD41BBM2Y0NNrwXpFyD7ShDPjhTA5EUSQnJ4f9+12xBA6Hg9WrV1NdXc3xxx/fKZbEu42eGHC6axJWWlpKUlJSO2MxLi6OG2+8kXfeeYc9e/Zw1lln8emnn0Z8noeD4RcKQmIKpuvvBVXF8d8lONeGngRTd8xvXQZRbRXO778Kqaxb0UzZvwe1pelgv/q0xc1Udo8x49zyU7u/lf27af37DSj1oQtteGN751loakDMH4L+lLM7fe5PBOBwJNq/o/r6eh588EGuuuoqjj32WN5//31mzJgR1TZ84es8LBZLtwuq+Gp32LBhHHXUUfz8888UFRUBrnGgrq4u6NjI7OzsqOW0URRFczXTOOTQjBkNDVwTXrckM7h2ZUId2MKddMfFxWE2m9mxYwcrVqygoKCACRMmxERsTLQykXc8ZseOHX6T28XHx3PLLbfw1ltvsX37ds466yw+//zzLttxf34kGS7+0I2ZjH7WhQBYn/8/lNqqkMoLegP6U84DQcD+ydsh3dtiagZCVg6oKvKug65mYlviTLWbjBn7B6/g8jE7iLxlHZZ/3RH2b1MuKsTx9TIAjJffhiB1zg7fWyIAvX2fR7LI0NDQwEMPPcTll1/O5MmT+eCDDzjhhBN69ZysVmvUYiRDJSkpieOPP56WlhZWrVrFrl27yM3N9Xk9fF13nU6H2WymoaEh4r4IgnDEGOcahw+9P1vS0IgBOiZ0tFgsnVzMumsnRFEUqqqq+OWXX5g4cSJ9+/YNqlysuAIEk1vC+5gDBw6QkpLi04XPm8TERG677TbeeOMNtmzZwpw5c/jqq686nXdHI6Y31Hj85ZyJNqHsAhjnXYeYPwS1sQ7r8/8Xcr8MvzkTTGaUvbuQN/4YUlmPRPPOzsaMUh65PHNHlIY61NJiHx/IKDu3oOzc0vmzLlAVBeuiR0BV0R17KrqRE3we11MiAP7u+67ei0ZbvgjH8GhqauKRRx7h0ksvZfz48Xz44YecdNJJvW6YQednfk8nzxVFkbFjx5Kenk5hYWG7xMre+OtXVlZW2LszHfuq7cxoHGpoxoyGBnTS17fZbJ0m292RIbu1tZWVK1diMBiYM2cONTU1QU/Goz0BiHZ9/naWduzYwYgRI4KuJykpiTvuuINXX32V9evXc/bZZ/O///3P705MT09COrbZnROzYGM0wLW7Yrrpb6A3IK//AceXH4TUlpCYjP7EWaCq2D95K6Sy0uBRAO12ZoTsnLbEmYF3ZkIJXna/r+z+1euNDv8ApbQkYB2+cH77icsIMsdhvPhGv8cFKwIQKcHcV8Gu5EejrVBobm5m4cKFXHzxxYwaNYqlS5dyyimnxIQR46aj4EukhmE4LsoNDQ3Ex8cza9YsduzYEVKiTUmSSEpK6lIhzVe7Hfsqy7K2O6NxSKEZMxoatA/+d7uc+XMzi2SQ8x40qqurWb16NWPGjGHo0KHo9XqysrIoKSmJmV2XSPB1Dvv27SMtLQ2j0RhyfcnJydx5550sWrSItWvXcu655/Ltt99G/VrF0gSrI5IkhZTYTsobhPEil/qW7Y0ncO7dHVJ7htMuQBVF5E0/IpeEMLEa6jJmlJ1bPN+P2KcfCAJKF4kz/V3/QO8r1V51Ch3+gcvtLUAdHVGbGrC9+QwAxrOvREzL9Gk8q6oakoHpXa6niJaBEw4tLS088cQTXHjhhQwbNoylS5fyu9/9LiZ/Y62trT7VK3sCVVWxWCzU1NTQv39/DAYDxx57LBaLhdWrVwd9f2VmZlJdXR3S99txV9mdOFRLoKlxKKEZMxpHPIqiIMtyu4d6IGMmnIG4Y5k9e/awdetWpk+fTlpamuf9pKQkkpKSKC2NzBWnt5WK/LFr166gdmUC9SU1NZW7776bF154gZUrV3LeeeexatWqaHYzJvB1DUI1ZgD0p85FGjcVbDZsT98XkjqZmJ2LfspMAOyfvBN8uQHDQKdHbaxHbUuUKWa2uU82NaA2+3ahCReluM3Q6njJRAkxbzDSiMDZ4jsaKLbFz6M21iHmFqA/fW67Y3y5T4YaZ9Dbk/nubr+1tZWnn36aCy64gIKCApYuXcoZZ5zR6+cdCIvFQnx8fI+26b4eTqeTAwcOkJeX1+4ajR07ln79+vHtt992Uivz9XwQRZHk5GTq6uq6PNb9fsddZbfqmrYzo3EooRkzGkc8DoejnUuUIAgoihJW7hh/uAcTRVFYv3491dXVzJgxo1PAqaqqpKenI4piJ//nUNypYnFnp7S0lJSUlKCEFYK5tmlpadxzzz08++yz/Pe//2Xu3Ll8//330ehqTODrGoSzCyCIIqbr7kFITkXZsx374hdCKm+YdSGoCs7vv0CpqQwunkJvQBw4HFSQ2+JVBHM8QpussVIZ3bgZecs6QMV1ybwyr+cNxvynR7q8n7zPSSnegeOrJSCA8YrbEXRdy/WG4mrWG+p6PdWe1Wrl2Wef5fzzzycnJ4dly5Zx5plndnI57cnnU7BtqaqKJEnd3JvObaqqSklJCbm5ueh0nQUm+vfvz6RJk/jxxx+DSrKcnp5OXV1du3w14YxlWr4ZjUMJzZjROOLpuCsDQWYFD3FAttvt/PDDDyQnJzNp0qSAamV9+/bFarW2U6cJJgC4K3pzZTTUWJlgycjI4P777+epp57i888/54ILLuCHH36IejuxQDg7MwBiWibGa+4GwP7RGzi3/Bx8m0PHuHY2nE4cX74f9D0ktUk0e4sAuNy9VJTy6CmaKbVVbTExQpsZ4/IvMz/wEnH/et2T3yYYVFXF9vJCUBR0036DbkxwSTdDEQHojbxH3d2ezWbjxRdf5NxzzyUjI4MlS5YwZ86cmFBk7Kl4tnDZt28f6enpAZXU3GpnxcXFFBYWAv7PRRRF4uLiaG5uDt6t0s/9oe3OaBwq9P6TRkOjl+mo3KIoStQH4cbGRlauXMnQoUMZNGiQ5/1Ak4z+/ftTU1PTbpIUjZwrvUFFRQWJiYldKphFQlZWFg888ACPPfYYH330EfPmzWPt2rXd1l5vEM7OjBv95BPQn3gWqCrWZ+5HbQpexlV/uiuJpv2/S1EtLUGV8STP3Ln1YNxMVi4gRHVnRi78xfXCawdFyMxGN2xsyJNX58rPkX/dAEYzxotvCrqc2WzGarWG1NbhgN1uZ9GiRZxzzjkkJiaybNkyzj33XJ87DN70llHhnXTY+1koy3Kv9KmsrAyj0dgpn5gvdDod06ZNQxAEVq9eHVAoJj09nZqawPmVglHD01TNNA4VNGNG44jG166M3W6PaiboAwcO8PPPPzNt2jSysrKCLicIAvn5+ZSWlmKz2Tzv9TTRaHP79u3dsivji+zsbB566CEeffRRPvzwQy666CLWrVvXZblYdM3riE6niygw1zj/ZoQ+/VCrKlyyw8G2O+k4hD79oLkRx/JPgyojDRkNAih7toPddf+K2dHPNSMXrne9cLZNvJJSMd/7TMj1qK3N2N54CgDDnMsQM/sEXVav1x9RAdMOh4PXXnuNOXPmYDabWbp0Keeff36PuWlFQ2nM+7nW0tLS4zlmysvLEQQh6MSYbkaMGEFubi6rVq3ye88ZDAZEUQxoYPtKwNzxWd8bMvcaGuGgGTMaRzS+VrkdDkeXK4uBBlPvz0pKSti9ezczZswISylHkiTy8/PZt29fp4Gppybf4bjgeVNdXY3RaOwxpSB3//r06cNDDz3Ev/71L959910uvvhiNmzY0CN96C4i2ZkBV9yK+cb7QZRwfv8ljpWfB1dOkjCcfgEA9v+8ixpEH4SsvgjJaSA7UXZvB0DMdrl8KVE0Ztq7zKnoJkxH6tMv5Hps77+IWl+D0Kc/hlnzwupLbxjEPdmmw+HgzTffZM6cOUiSxNKlS5k3b16Xz8to0x3S0T2pZFZeXg64nlHhkJeXx7Bhw/juu+/8GiyZmZlB553xdT0FQTiiDHSNQxvNmNE4ovH1sLbb7V0GqQcaTN2f7dy5k9LSUqZPnx7RTo9eryc/P5/9+/e3CzIOJllldxBK/YIg8OuvvzJy5Mhu7FFgcnJyePjhh3nwwQd5/fXXmT9/Pps2bep0XCz603dEkqSI/diloWMwnHMFANaXHg7a5Ut/whmQmIxacQDnTyu6PF4QBKQhbflmdm52vedOnNmmcBaIYGLElJpK1LK97gNcCS4nHBPyb0DeW4Tjs/cAMF12G4K+a5GKjhiNxl5xNeuJ+9bpdPL2228zZ84cZFn27Hh29Vw7FHY7wbUzk5iY2CNtVVRUoKpqO0MmnOuUnZ3N+PHj+f777zspnYHL9VGW5bAMEndcl6ZqpnGooBkzGkc0vh70blnmSAbibdu2UV9fz7Rp06ISf6PX6ykoKKC0tLTLQONIgz6jSX19PaIo9thEIRD9+vXj0Ucf5W9/+xuLFi3i8ssvZ+vWrV0XjDGi8b0Z5sxHHDYOWpuxPn1/cDstJjOG384GwP7xW0H1RRwyGgB5pyto2eNmVlWBKgeeZAWj3idv+8X9oeufpEc3bmpI6mWqqmJb9AioCrpJx6ObcEzAsv4wm81dKprFyuQ+2GeELMu89957zJkzB6vVygcffMCll14alCJhKO30Nk1NTSQkJHR7OxUVFciyTN++fdu9H+p1ch+flpbGlClT+PHHH6mtrfV87r7P0tLSuoyd8YV3bJFmzGgcCmjGjMYRi6qqPn2C3TszHQeYYCcimzZtwmKxMGnSpKj0041OpyM/P5+ysrKglZMC0RMTjV9//ZXhw4d3ezu+8Pd95eXl8cQTT3Dffffx3HPPceWVV7Jt27Ye7l34RMNYFSQd5hvuA5MZedsv2D96o1NZx+qvaX3wFlruvAzrG0+gVJWjP+Vc0OlRdm5G/nVjl32R3MbMrjZ55rRM0BtAdqJWVwR1HoGQt653d9jV3sijEOK6npR699v5w/+QC9eBwYjx0lvD7kswxkysTO67epbJssz777/P7NmzaWhoYPHixVx++eVhJbvtLUIxHC0Wi09jJprGZ0VFBU6nk5wc/+p64fy2ExISmD59Ohs3bqSioqJdPcnJyTQ1NQUnp+6nbc3VTONQQDNmNI5Y3MH/HfM+OBwOn+4TwQw069atQxRFJkyY4PPzSCczOp2OgoICysrKaGkJTlWqt7BYLFit1nZJQUMhGkG+gcjPz+epp57i7rvv5umnn+bqq69m+/btEbXZk7jvXX//ujp/sU8/TJfdDqjYF7+AXHTQoLO9/AjWR+9C3rAGZddWHJ++S8sdF6K2NKOf8TsA7J++3WUfpUEjQRRRq8tRaioRRBExsy1upiLyuJmOEtO6CceGVF61tGB74wkADGde4onpCQeTyeQR6jhUURSFJUuWMHv2bKqrq3nvvfe4+uqru1WF0JtoGg+hPGudTqfP3aZoGZ8HDhxAURRyc3N9fu69ExIOJpOJGTNmsH37dvbt29fus5SUlHa7Nv7a0eSZNQ5lNGNG44jF6XS2y3jsJph4mI4oisLq1atJSEhg9OjRUe+rN5IkUVBQQEVFRbs8NLHG9u3bGTp0aNgDdE/l4xg4cCD//ve/+eMf/8gTTzzBH/7wB3bt2tXt7YaLd1LXQP+CQTfzDHRTTgLZifXJe1GtFuTdv+L44n1X7klZAVUBRQZLK7Y3nkB/xgWAinPttyjl+wLWL8TFI/Z3SZHLu9ryY/SJjgiAUl2B2qF93cTQjBn7kldQqysRMvtiOPPiiPoT7o5ZqPd4d8izK4rCRx99xFlnnUVpaSnvvvsuf/jDH3pc4as7d646yjF3/Kw7UBSFkpISjEZjJ9cyb6Jx3jqdjmOPPZbdu3e3S66ZlpZGfX192O35UvzU0Ig1NGNG44jF14pTVw9tf5//+OOP9OnTh2HDhgU8LlqDgiRJDBgwgPr6eo9rQXcScr4Op5Pa2lr69u0b0UDdk245gwcP5plnnuHWW2/l4Ycf5rrrrmP37t090nbHGI5A6PX6qOV/EAQB09V3IqRnoZSWYHvjCVdwvyi5c0/iGSYUGXnDasS+/ZGOmgaqiv2zdwOeiyAISINGo6qgtIkAiJm5oIJS3rUIQCDkX39pfy6ZOYg5eUHfM8qBEtfukgCmy25HMEa++xCMdHZXsUBdff+R/iY6SvJ++umnzJ49m+LiYt555x1uuOGGqCt7+ZIB7mn8GfkWiyXoGKBQcDqd7Nmzh9TUVDIyMoDwDNdQng2iKDJ9+nR27NjhGRfcSTSbmpqCbrMjmquZRqyjGTMaRyy+jJlwdgPWrVtHRkYGAwYMaFdPOISqFJafnw/A3r17u2WSEK77w65du9pdj+4mmuc+dOhQnn/+eW688UYefPBBbrzxRoqLi6NWvy9CyVIeaa6ZTm0npWD6wz0AOL5agnJgb/sDvEeJtstsOOMi1/HLP0Vtqm9fX4eJqzRsJIJwcGdGzM4FAdTKMiJB3tLemNFNnuFpsytUVcX6yiPgdCJNOAbp6NB2dPxhNBojjmfrCQNeVVU+//xzZs+ezY4dO3jrrbe4+eabiY+PD6uuUI6JtcWNxsZGkpKSolafqqpYrVaKi4vJyclpV3c4gf6hPBvgYHLNwsJCqqurAcjIyKCqqiroNjuiGTMasY5mzGgckSiK4ncQDmXA2bJlCwaDgSFDhkSlX+EM1tnZ2SQlJbFnz56oDTqRGAeqqlJaWuoxtHqC7pjkjBgxghdffJFrr72Wv//979x0003s3bu364JtRMPA8lVHtI0ZAN24KehnufLIODf/6HIr64ggIB01BUFvQBozCTF/CNgs2L9aGrBuccgYwGXMqLIToU3RLFhJaH84t/7U/hyOCmyQeF9L54/fIm/8EXR6TPMXRO3+iYuL61IEIFqEc3+pqsqXX37JnDlz2Lp1K6+//joLFiyISMmrJ3dPu2PBpr6+3q8xE057zc3NHDhwgPz8/B5303NjMBiYNm0aGzdupL6+Hr1ejyRJYcV0ud1aNTRiGc2Y0TgicRszwQ5Wvo4rKirCYrEwZsyYaHcvZFJSUujbty/FxcURTaYiTZAJsG/fPvr06eORpI4VBadwGTVqFIsWLeLKK6/kvvvu49Zbb+0UZOuLaOQB8lWHTqeLmpuZN8bzr0PMGwzNjQiZ7hwYAp7tGMBw7jWefhl+fyEAji/fR3XY/dYr5hZAXDzYLCh7ixD7BJ9rxh+ueBmv8gYT0sijApZxX0vVasH2+mOuYr+/CLFvXtj96IjZbO6xXDOh/K5UVeXrr7/m7LPPZsOGDbzyyivcfvvtUd2R6GlCeX4Horm52e916Ooad/y8pqaG6upqBgwYEHRuse5yuzOZTEybNo2ff/6ZxsZGUlNTO8XOBNM3VVW1nRmNmEczZjSOSNwPZ1/+6r78uzset2/fPiorK6Muv9yxL6FgNpvJz8+ntLQ0ZGGAaBgxboqKihg8eLDfug9Vxo4dyyuvvMKll17KX/7yF2677TZKS0PfXYjUuNPr9d2iMCQYjJhu/jvoDahV5ehOmIU4bKwnGSWqirxuped43bTfIKRlotZW41z1Rbu62rkViaJL1UxVkXdtQczs66qvqQG1qfN96k9pyft9uXB9u8+lcZP8JrrsWJ992auolWUIGX0wzJ7v/4KEgU6niyn1J1VVWb58OWeffTY//vgjL7/8Mn/6059ISUnplf5Ec2EjFKGLQESSMNN9bymKwt69e7Hb7RQUFPjNLebr3u7OxZ64uDimTp3K2rVrkSTJZ3LNYARvtHwzGrGOZsxoHJG4jZmOg4tbJcqNrwd9RUUFe/bsYcqUKX6P6Ug4q/HhqCPp9XoGDhxIY2MjBw4cCFnQINKBtaamhvj4+G4JqI0Vxo8fz2uvvca8efP405/+xJ/+9CfKy8t7rP1Qd2ZCufekvEEY590Aqorzh68wXnM3QlKqKyElYP/4TY+ksqA3oP/d+SCA/ZN3AsZFSEPHgCAg79iKYI5HSM0AQUCp6hw34+se7DhxlQs7xMtMPM7vOXmXU8r2Yv/oTRAEjJfegmAK3g0o2OvYUyp8XbFy5UrOO+88vv/+e1566SXuvvtuUlJSerVvsXBdOqKqKpIkhV3eYrGwe/duUlNTuxQ8CfXeCOWe80dCQgKTJ09mzZo16HS6TpL+gdpot4CgGTMaMYxmzGgckfjzAfY3sLkf6rW1tRQWFjJ16lTP6lskCcn89SEUfKkj9e/fn/j4eHbv3u3T7SXaRoybHTt2MHTo0KjU5SZW3dQmTpzIG2+8wdlnn81tt93G3Xff3SPKct21M+Op/7TzkMZPBbsN21P3ojv9AgyX3oo4fDw47Nhef8JzrOE3Z4I5DmVfEfKGNX7rlAa75MqVHW3JM7PcrmbhyTM7t3bIL3PUMUGVs772ODgdSOOmoJsyM6Q2g70PDQZDj7ma+eL7779n7ty5fPPNNzz77LP85S9/aZfrKdxkwIcy/s7R4XB0acgEuj7V1dWUlZWRn58f9O5OKM+zaCTIBUhKSmL06NEUFRV1yjkTqL12yWU1VzONGEYzZjSOOFRV9RgzHR/eTqfTp4uAIAhYrVZ++eUXpk2bFvTOQ3cMXBDcBCQlJYX+/ftTWlpKTU1Nu7Kh7v4E06bFYsFut0fdhaWnJlvhtjN58mTeeustzjzzTG655RbuueceKisro9y7g4iiGNLEImQFJVF0qZslJqPs2Y5gbcV4xgWYrvoTiBLOtd/i3Pij69iEJPQnzgLA/pn/JJrC4JEAKKXFqE0NiFnuxJmhu+l1jJcR+w9CTMvsspzz55XI61aBTodx/m3dZiSbzeYeEwHwZs2aNVxwwQV8+eWXPP3009x3330eSeBAxOpiQUfC+X12dW51dXVdxg35qsPtVuZ0OkOKj4mUSJ6F2dnZ5ObmsnHjxqBTB3i7WWsiABqxjGbMaBxxBFrVVhTFr7/zzz//zLhx40LKht0dLgUQ2irxgAEDcDgcFBcXI8ty2JOXrlwkdu3axaBBg0KutzuNle64pv6YMmUK77zzDqeeeio33HADf/3rXz3SqNGmuyegYnoWpqvvBsC+7HWcheuR8gah/905ANheWYjqdLm6GX53AYgi8sYfkYt3+KxPSklDaAv8l3cVuuSZATWMxJly4bp2f+umnNBlGdVuw/rqo67+nn4BUr+CkNsNFpPJ1OXOTDTv+bVr1zJv3jw++eQTHn/8cf72t7+Rmdm1cXeoEc497y/m0U19fX3Iiy/ebmV9+vTpUWMwUsn/YcOGIUkShYWFQZXRYmY0DhU0Y0bjiCNYY8Z7wrF582YyMzPDTn7mj57YdRAEgezsbDIzM9mzZ4/PINBQ6vKFoihUVlaSm5sbtTrdRHKNeiN+Yfr06SxevJiTTjrJI+scyLUjVtFPnYn+hFmAivWp+1CbGzGecxVCUgrK/mIcny8GQMzO8bhs2T95x2990mC3RPNWxOy2nZlwjJmtB+NlVFVFN2F6l2XsH72BWn4AIS0Tw5zLQ24zFEwmU5cSuNGYAK9bt46LLrqIJUuW8Oijj/J///d/ZGdnR1xvdxNLbm0NDQ1BGzOqqlJeXk5FRQV5eXkRiwZ01/G+8L7fZs6cycaNG2lsbAy6jLsfmkGjEatoxozGEUeg3QlvAQD3/8vKymhqamLYsGGe46K1GtdTq3qCIBAfH8+AAQOora2ltLQ0qm4D+/fvJycnJ+piCBDdjOc9yYwZM3j//feZMWMGV111FQ888EDUjJqeMtKMly9A6NMPtboC66KHERKSMMy7DgSwfbAIpc6182SY5ZJpdv7wJUqNbxc7aagrbkbetbkt14yKUtZZnrkrFxhn4cF4GSEhCXHQyIDnoFSUYl/2mut8Lr4ZIS70xJChIIpi0G48oSIIAuvXr+eSSy7h3Xff5V//+hf//Oc/6dOnT9eFe5mudkm6wn3PR/O+b21tDcooaW1tpaioCIPBQEFBQUQCJ+EkzowG7utmMpkYP348a9aswW73L6nuqx+aMaMRq2jGjMYRRzA7M+4Hf2trK4WFhUyePDmqfeit1UlJksjLy/OIA/hanQtn8Ny9e3fQLmaHio9+NBAEgRNOOIEPPviAadOmceWVV/LPf/4zZOnsjnRXrpmOCOZ4zDf+zRUrs+pLHKu+QD/z9y4DorUZ+zvPASANGY00Yjw4nTi+XOyzLo8xs2MrQmYOIKBWl6PK7eN//N0fgiCgVJWjlh/czdEdNR3Bj1uoG9vrj4PdhjR6Arrpvw3uxCPEX4xBJPf+pk2buOSSS3jzzTf5xz/+wcMPP0xOjmuHK5Z2O/wR6e/e7fbk7foUDQLlg1IUhdLSUqqrqykoKGgnpBBKXbGAd99ycnLo168fa9euDbq8d6yphkasoRkzGkccsiz7HQjdhox7MvLTTz8xceJEdDpdVCcM3TXoBdvH5ORkBg4cSFNTkyeQNdQ63DQ0NGAwGPyuVh4KE63uRhAETjrpJD788EMmTJjA/Pnzefjhh7t09QDf10+v1/eIMQMuWWXDOZcBYH3pYdTqckyXLQDAsfxj5J0uhTL9Ga7dGftXy1AtLZ3qEfMGg8EAzY1gs4Bej6rIqNXBK8B1UjGb7F+SGcD5y2qca78FUcJ42e09Ntk0Go1RUzTbunUrl19+OYsWLeJvf/sbjz76KP369Wt3TCxPoqNNOOIlvmhubsZs9i/N3dLSwu7du4mPjycvLw+dTtdlnaFO9ntrHEhOTsZoNJKens62bduCrlfbmdGIVTRjRuOIomMeGeiQ4M9rRXXDhg3k5eV5fKp7asIQiStFqOppubm5ZGRkUFxcHHSwese+7dq1iyFDhkSlT4c7giBw8skns2TJEkaNGsXFF1/MwoULaWpqClimIz21M+NGP/syxCGjoaUJ6zN/Qxw8Ct1xp4OqYl30CKqioDt6BkKf/tDSiGP5J53qEPQGxAEjAFB2b0PMzEUgNHlmpXCDV4UiunFT/R6rOuxYX3kEVBX9qeci5QdO5BpNozsYEYCu2LZtG1deeSXPPfcc9957L0888QT5+flR6mHo9HTCx1D6EQ61tbU+42VkWWbfvn3U1dUxYMAAkpOTg64z3F2jaC+UBfpe3It1RqORgoICqqqqglpUAc2Y0YhdNGNG44hCUZROxoL3g98d/F9ZWYndbmfAgAFA5INNKAZKOJmtI5EtjYuLY9CgQciy7Dcvja9y4BrcGhoaul096XAziARB4LTTTmPZsmUMGzaMCy+8kMcff7xTQjt/RLoz432/BHPviDo95pvuB3Mc8tb12D9+C+OF10FcAkpRIc4VnyGIIoYzLgDA/tm7ndzHAKShrvgWeccWhD6hiwB478yIA4cjxCX4Pdb+6buoZfsQUjMwnndVu8/8JebsSLi/e7PZHLYxs337dq6++mqefvpp/vznP/PUU09RUFAQVl3RJJrXJ9Ky0aCmpqaT21htbS179uzxyNqHm0wz1Pww0Xy+dXVd3W2lpaVRW1vL+PHj+eWXX7osGyvJYDU0fKEZMxpHFE6ns53kZEcEQcDpdLJlyxbGjx/f7n03wQ4WHd/rzgl5NILks7Oz6devH+Xl5ZSVlQW1CldSUtLJ5aU7OJQH0a4mCGeccQbLli1jwIABXHDBBTz11FO0tra2O6YjBoMhoiR23nUGe++Iffp73Mvsi59Dra/BePYVANjefga1pQn98acjJKWgVpbiXLO8Ux0eRbMdWxCzQpNnVirLUCsP5qXRHeM//kWpLse+ZBEAxotuQIgPT3kqXDngcNzMdu3axbXXXssTTzzBH//4R/797397FlMOR3pigcJf3hSApqYmjzHT0tJCUVERDoeDQYMGha1UFknfon18V8TFxWG1WklKSiIrK4vt27d3uaMDobvSaWj0BJoxo3FE4cvNzBtRFNm1axcDBgzwm0/Gl3Tz4YJbrScuLo49e/ZQVVUV8Dz37t0b0oQrVq9ZoH5FQ4GqK0RR5Mwzz2TZsmXk5uZy/vnn88wzz2CxWHo9ZsYb3QmzXDLMTifWJ+5Fd9IshL55qPU12D5chGAyo//t2QDYP3unU9+lIS4RAKVkJ0KaS0ZYKQ8ucaa8bX27v/UTj/V7rO2NJ8FqQRw2Dt2M3wV9fpHiXrTwpWjm/rvj+7t37+b666/nkUceYcGCBTzzzDMMHjyYWCPWk9f6ouMiVMe/nU4nJSUl1NbWkp+fT3Z2do8qTHbn8cFgMBiwWq2MGDGC8vLyLmX7NREAjVhFM2Y0jii6ehC3tLRQVVUVcILelWtAqDEvsTjBT05OZtCgQQiCQFFREfX19Z2Oqaurw2w2h5T9OlbdxQL1qydjpURRZM6cOSxdupTMzEzmzp3L888/32mVX6fT9Yr/uiAImK6+CyE9C6W0GPu7z2Oa3yYG8J/FyPv2oD/lbNAbUHZuQd6+sX35jGyEtExQZGj7LQYbM+PcetCYEVLSEXLyfB+3+SecP/wPRBHTFbd3qXYWTbx/y5IktXvedAxcLy4u5sYbb+TBBx/khhtu4LnnnmPo0KE91ldvYukZFCimMVo0NTXR0tLCgQMHyMrKon///kEF+HdXf3qL5ORkj7LiUUcdxfr16wMerxkzGrGKZsxoHFF09SDesGEDI0cGzlsRDKEG4vcWXblAZWRkMHDgQKxWK0VFRe1iOnbv3s3AgQN7opsR0xO7K5Hi3YYkSZx77rksXbqUlJQUzjvvPBYtWtQuGWN3T6r81S8kpWD6wz0AOL78ABQFaeIMkJ3YXn8UISUdfdtuiOOTt9uXFQSkwaNc9bfUA8HHzMhbfvK8lo4+zncMh9OB7eVHAND/dg7SgGGdjukp/Lma7d27l5tuuom///3vXHvttbz44ouMGDHCZx09NXEO5v7uredUoEWjcOqpqanhl19+oW/fvgwYMCCgolko/TkUSUhI8DzTk5KSyMjIYMeOHX6PF0VRM2Y0YhLNmNE4YlAUJeCDuLi4mNTUVOLjuzepnptYWOEL1gWqT58+5OXlUVtbS0lJCRaLhfr6+pAD/yM550gmEdHIcdEbSJLE3LlzWbJkCWazmXPOOYdXX301pGR34RLomunGTUF/2vmAivW5BzDOmQ86PfKGH3H+9B36089HVRSca1egHChpV1Yc4oqbUcr2AaA2N6I2tc+707FtpfIAalW552/91Jk+++X4/H2U/XsQEpMxzr062FPtFjoaM/v37+fWW2/lvvvu46qrrmLRokWMGjUqYB2H08Q52oR6berr6ykqKkKWZeLi4mJOGS4ahHpNRFFEFEXPLu/w4cPZv39/JyPc20VSM2Y0YhHNmNE4Ygj0ELbb7RQVFTF27NiYWg3tCYLth16vp3///mRnZ7Ny5UrsdnvIk+pIzjkWjL9giXZfdTod8+bNY8mSJeh0Os4++2yWLVvWI0aNP4wXXo/YfzBqQy22Ja+gnzUPANtrjyH26Ydu4rGAiv3z99q7Xw11TeCVPdtd7mKAUlXWru6O10/e+svBP3R6pJETOvVHqa3C9v6LABjmXY+QmBL5SUaAW9GstLSU22+/nT//+c9ceumlvPLKK4wZM6ZX+xZLdPVbiVRG223E2Gw2BgwYQFZWFi0tLaSmpobc11D6GIjuzC8Tal8SEhI80syiKDJq1Ci2bt3a7hjRy1VTM2Y0YhHNmNE4Ygj0kN+yZQsjRozo5Ofem4Q7IQ41XifUdkwmE0ajkSlTplBaWsrevXvbuT8dKXTlotcdben1ei666CI+/PBDBEFgzpw5vP322xEpm4XSvjeCwYjppvtBp0NetwoxKR0hLQu1shT7x29iOOMCVBUc336K2ljvKScNHA6ihFJTCamunT2lYn/A9p1b1rn6AYiDRyHoOydotb3xNFhaEAeNRH/i74M+j+6ivr6eBx54gD/96U9ccMEFvPbaa+0UEnuS3s4H00kMQXZi++Blmq8+nebzptKy4AIcP/zXZz2BZLTdzy9f32tdXV07IyY7O9vjJhVI0TISmftYIBTlTXDFzXjnucrOzqa5ubmdomKoUu4aGj2NZsxoHDF0fAi7H/pWq5WmpiZycnK6XUI5FMLtR3fH67S2tiKKImlpaRQUFJCZmUlFRQV79+7FYrGEXN+hQG8nDOzYlsFgYN68ebzxxhtYrVZmz57Nu+++221Gjb9zlQqGYpx3AwC2d59Bf3pbnpllryH0yUMaMBRsVhz/XXKwLlMcYt4gBEAwueIVlIqyTnV7I29e6yoL6Gec0ulzZ+F6nKs+B0HAdOUdfoP+g82VEsluQEVFBXfffTe33347J598Mm+88QYTJ04Mqmx30RMT0I7X1pf8t+2DRdjefBrLPxdgf+851LoqQEXZvxvrY3/G/vVHIbUpimK7Z7aqqh4jxp0nzG3EuPGXLNPfeRzu+FJGHDVqFFu2bAE63zvdvXCioREOmjGjccTQUf3J/ZD+9ddf20mhhjqR6a6JQqyugO3evbud2pvZbCYvL4+srCyqqqooLi5ut6rnJpYMxVCJxZgbt/rS5ZdfzgcffEBTUxOzZ8/m/fff71GlM/3p5yONnQw2K87vv0IcNg5sVuxvPY2hzfXM8cX7qPaDu3fSUJdEM22JNQPlmlEqSlFrKz1/644+rt3nquzE9vJCV19OPAtp8KiQrnewCTS7yu5eWVnJPffcw6233sqZZ57JW2+9xbhx42L2dxxtunQXUxQcX36A/aPXkTescRdq93/7O8+iOoOXHPeO5airq2P37t1+jRg31dXVpKenh1R/tOktV2Z/7cbFxbUTd8nIyMDhcNDY2NjuGrqf4bHivaCh4UYzZjSOGHy5I9jtdurq6sjNzQ1Y1teg6Ka7MiPH6sS/srLS5/UymUzk5eWRk5PjyaTtnbcgHJe2aBAL17G7ckS4V1SNRiNXXXUV77//PjU1NcyePZsPP/ywRyYdgii61M0Sk1F2b0PMzQdRxPnDfyElAyE9C7WhFueqLzxl3Plm3O5ngdzM5MJ1B9vK7IOY1l50wvHVEpSSnZCQhOGCa13H9WCC2urqav76179y00038bvf/Y63336bKVOmAK7vKBZcMHvboFKdDuSSXeimzkRI8TIkOk62G2pRyg7eC131W5ZlKioqPAkvAxkxbmpqaoIWLumu+6gnn0ne19Bfu0lJSZ64GTfu2BlfLma9fT9paHREM2Y0jhg6JsxUVZVt27Z1yu0QjotJKINTNAaC3hpMqqurSU5ODni+BoOBfv360a9fPxobGykqKqKmpqbXVvMOh4HX1/U2GAydBABMJhPXXnst7733HmVlZZx11lksW7as23dqxIxsTFffBYBz+SdIE1wJLe2vP4H+lHNdrz89mERTalM0U6tdCmWBcs04N671vO64K6PU12B773kAjOdfi5gcvaDurqitreXvf/871113Hb/5zW949913OeaYY9od40+euafpSeENtaUJZ+F67P95D+szD9Dyx0tovmQmlj9ehOOLD1DrawL31Rx38LWffttsNvbv309JSQlGo5FBgwaRlZUV0IhxY7fbMZlMPf5c6K3nUDDffXx8fLudGcDjildbW9upvsPhmapxeBFcligNjcOAjg9gh8NBbW0t48aNa/e+JEkBA0QjJRr19tZuQyi5ZfR6PTk5OSiK4tmpMZvNZGRkYDB0DuDuCbrze+1OfE0e9Hq9X/91s9nMDTfcwGWXXcaiRYuYPXs2V111FWeccUa3nb9+6ok4Z87CufwTlD2/Qnyia8dkxu/AZEbZtxv5l9XoJhyD0Lc/xCdBi2s1WK0qR5WdCFLnIcm5Za1nBV8/49R2n9nffhZamhAHDEP/m9ndcl4dqaur49lnn2X9+vXceOON/OUvf/F7TY1Go0+Xy0D09j3acbIaMDlwZRlyyU6Ukh0oxTuQ9+xErSr1Pujg7ospDiEhEbWmClQfCxuihDR8HGJGtt++NTU1UVNTgyiKZGRkEBcX5/dYf+XdeWV6+hrH+nNHp9Nht9vbPZtHjx7Npk2bmD59uue93tph19AIhGbMaBwxyLLcbqDevn17u1gZNzqdDofDEXDC3dsTjt5AURSam5vJyMgIqZx74pGRkUFzczNlZWUoikJGRgaJiYnd1FsXHb+nSFeou0OlLNw6g0lgFx8fz0033cTll1/OCy+8wFlnncXVV1/Naaed1i33r2n+AloK16NW7EccPBpl11bsy15Fd+ypOP+3FPunb7mMGVFEGjLSFTshSqDIqNUVCNnt3ReVigPQUOf6Q29AHHQwoa28YzOO5R+72r38dgRJivr5eNPQ0MAzzzzDzz//zPXXX89dd93V5TU0mUzU1dWF1I4/kYJeTa7rsKPs241SsgO5eAdK8S7kkh3Q0uzzeCGzD1L+EMT8oYgFrp1v22uPolZXACAOGIayt8hl1AgiyE6E5DTMf/hLp7rciyENDQ3ExcWRm5uLXq8P6zwqKyvJysoKq6w3kexOhPpdRmsnpKt2k5OTaWxsbPd8d+dca21tbWc4ajEzGrGGZsxoHFG4BwVFUaioqPCZ78Gt7hLImOlK1vNwNHRKS0vJzva/ahoMCQkJJCQk4HA4qK6uprKykqSkJNLT04NyEQmVaH4P3fGd9tR9kpCQwIIFC7jqqqt4/vnnefHFF/nDH/7AySef3Mn1MqLkpHHxmG+8n9Z7r0bZtRUhs48r2aW1FUQJefNPyHu2Iw0YhjRktMuYMZmhtRml4gBimzHj7od3vIw0fKxHpUyVZayLHgFAd/wZSMPHde5MlGhsbOT555/nhx9+4LrrruPOO+8MKTdTNNSfujMvSce65fpalJKdKMU7kYt3IJfsQD1Q4hFraIdOh9hvIGLeUKSCIYgDhiDlD+6U40eprUJtaUbI7IPx0gXoJh+PWlOJY8VnqHVViPlD0B97CoL5YMJii8VCbW0tVquV5ORkBgwYEPEzorKykrFjx/o992Dxjh0Jtg63UdLTLsne7QciKSmJAwfau3tKkkRBQQG7du3yXLdo90tDIxpoxozGEUHHlaT9+/eTk5Pj81j3drt7VcpNVytkvb16Ggod+xpM3/fu3dtuQIsEvV5P3759PSpExcXF6PV6UlNTSUhIiEobvjiUvqNg8DdB8neeiYmJ3H777R6j5rnnnuP666/npJNOipranDRsLIaz5mNfsgilsQEBcK76Emn8ZOQNa7F/8g7mm/6KNNiVPJO2eB7vuBl3/50/rQRVRQFMx53h+dzx9UfIuwsRzAkYL7wu4j77oqmpiRdeeIGVK1dy7bXXcttttyHYbe1dp2KUYO5zVVFQy/fjLG5zESvZgVKyC7Wm0neBxGSXwZI/BKnAteMi5uT7zPnTETEtk7i7H0csGOqR4xYysjGefXm742RZpra2lsbGRgwGA+np6SG7kgXCZrN5nus97e4b6/lrRFHsJNGsqiq5ubn8+uuvnr8Pp+enxuGDZsxoHDF4P4hLSkr85n7Q6/U+g3Y7Cgh0JJiHfLQHg3Dr85UTIlBdTqcTu90edUNDEATS0tJIS0vDarVSV1dHRUUF8fHxpKWlBRVbE+rq6OGEXq/HbrdjNBrbvd/VeSYnJ/PHP/6R+vp6nnvuOZ599lluuOEGTjjhBL9lQ3F3MZx3Jc5NP6Ls3ALJadBQi1rvcrdy/vAVyrw/IA1pM2ZsrtxE3vLMoiiiqirOretAEBAB3aQZruMa67G9+yyCCsa51yCmZnR5D3h/3tWxLS0tvPjiiyxfvpyrr76aW2+9FcfHb9Fy3e+hphLiEzGccg6Gc64IaiIvSRKyLCN1sxucN52MW2sryt4il8FSvBO5eBfK3p1g9Z0XSuiTi5Q/DLFgCFLBMMT8wQgZ2RH9fgLtnjU1NVFXV4csy1HbhemIxWLp9Ds5FPHlOtvV2BSovHc9kiThdDo9su9uMjMz2b9/P/369UNVVc3NTCPm0IwZjSMCRVE8EyS73Y6qqn5X/PR6vUdS2HsCF0kSy2DrCNU/uqfcqPbt29elfHWkmEwm+vbtC7gmN+Xl5TidTpKTk0lNTfU7uelpAyWWVif9GTPBkpKSwp133kltbS3PPPMM//73v7nhhhs4/vjjg85R4QtB0mG+6X5a/ngxNNaBpEMp3omQk49aWoLji8UYL7oRoW8eatleAJTy9i4uamUptLbFZGT2RYh3xVfZ3nsOmhoQ8wajP/UcV3tB/K58vfamtbWVl156if/9739ceeWV3HTTTYiiiG3xC9jee8Hl4qaq0NKEfemrKBUHMN/yQJfXwq1o1nGnN1iCvd88rk+1VSglLhcxpWQXSvEOlLK9rr577yqpKhhNiHmDkfKHIhYMdu245A1GiAuvr26CeY7Z7XZqa2tpbm4mISGBPn36RCQM0lWb5eXlEbvJdiQWngXhxOD4w61qlpyc3O79wYMH88svv9CvXz+X+2cP5rHS0AgGzZjROGJwD3TFxcX069fP73Hefu7BSDJ3mSwuhElgb/oiBxoU9+/fz6RJk6JaZyASExNJTExEURTq6urYs2cPOp2OtLS0iEUDIo4LiRFDBnzLM/sj0L2alpbGX/7yF2pqavj3v//NM888w0033cSxxx7rOSbU6yb2zcM4fwG25/4PaJtoN9UDYP/fMgxzLkcaOgan25ipLG1X3rnpR89r/eTjAZCLtuH471IAjFfc7lP9LFQsFguvvPIKX3zxBZdddhnLli3zGM6q3Yb9k7c8sToeQ0BRcH7/FfI5VyD1G+CnZheRGjN+4/NkJ8qBkoNB+SW7UIp3ojbU+jxeSM1AzG8zWPKHIuYPQczp7xJgCNBOOPi7z5xOJ/X19Z5kjGlpafTp08dn+VD70zEfSsfy5eXlUXOTddOdz4JAOyjdRXx8PPX19Z2Mmbi4OFRVxWq1YjKZuq19DY1w0YwZjSMC74GurKysndRkR3Q6XdBBu4dTIKS/QdLhcKCqqt9BLNDEI1L1MFEUSU9PJz093bOSW1lZidFoJCUlhfj4eL8Dvr/vJpaMkUgxGAw0NTUFtfMXzL2anp7OvffeS1VVFU8//TRPP/00N998M9OmTQvruulP/D3y+u9xrv0WJB00NUBiMjQ14Fj+CdKQUThXfAaAUtl+Z8bxw/8O1nPSWaiKgvXlR0BV0U0/Bd0o326ivvB1j1qtVl577TU+++wzLrnkEpYuXdrJFUzev8flitUxTqbttbJzc0BjRlVVjEYj9fX1QffVZz0tTS4J5OK2wPySnSj7isDhw5AVRcScfMS8oa6A/IKhiPmDEVO7ViEMxR0vWNwGTFNTE4IgkJycTEFBQZeJiCPBV/lABmW0FMOiSW88p8xmM2VlZT6/+/z8fIqKihg1alTMXSsNDc2Y0TgicPv4Njc3o9frO/kEa/gnkFgCRH/QdQ+kHes1GAyeVVyLxUJDQwMVFRXo9XpSUlJITExsNxE7XAg0qTQYDDgcjqh/B5mZmdx///1UVlby5JNP8uSTT3LrrbcyefLkkOoRBAHj1Xch79qKWlvlerOlCQD7Z29juvXBgwc3N6I2NQCuc1Z2bHa9bzAh9huA89tPXO+Z4zBefGPI/XBjs9l44403+Pjjj7nooot8GzElO3Gs/Bznd1+4K/BdcXyy7/e92jWZTO12zwJ9n6qqolaVIRfvRCnejlKyC7l4h8vlzhfmeE9QvlgwxCWH3H8QgjG81fNg3PGCwZcBk5+fH9CA6U6XrcbGxoA7Y4fy8yLS6+ZdPpAISG5uLkVFRZ4yGhqxhDaj0zii2LNnD/n5+UEdGwv+0G56sy/79u1jypQpPdZeMOdpNps9ye9sNhv19fVUV1ej0+lISkoiKSnJ58Qplr7TYAnUX3dOpO4iKyuLBx54gIqKCh577DGeeOIJbr31Vo4++uig6xCTUzH94R4s/3eT6w1FAZ0etaocpWIfGE1gcwluKFVlAKjlB8Buc5UfPgZamrC99QwAxrOvQEwPPVeI3W7nrbfeYunSpVxwwQUsWbKk3aKGUlmG4/v/4lz5uWvXQwUEPHlw2iGIkJCI7qhpfttz32uiKLaLMfAY3A47yv7dbUpiO125W/bsgNamtrZV14aQqxBCZh/EvINKYlLBYISs3IMucL2MtwEDBGXAeNOdv8vy8nKf7mw9TXc8f6K9i2U0GrFYLJ1iSkVRRJIk7Ha75mqmEXNoxozGEYF7Jam6uppRo0Z1ebxbLCCcgSKUcsEe21sTcPeKciyrABmNRk9gr91up76+nuLiYiRJ8hg27pV3X9exJw0ctztLtNrsqX5nZ2fzz3/+k7KyMo9Rs2DBAo466qigyuvGT0V/+lwcn73nesPpMsAcn72HOGA4yq8bgIPyzI6fVnjKGk6ajW3xC6gNtYg5BehPmxtS3x0OB2+//TYffvghc+fObWfEqE0NOH78Bueqr5C3Hsxpg06P7qhj0B13GmK/Alr/eLHLpct9vQ0GzLf9M6Camfd3I7Y04di4FrWkzUWseAfKgWL/uVtyByAWDEMqGNwmhTzEk7ulN+5Xf7S2ttLY2EhrayuSJJGYmEheXh6iKEZttyAaVFVVhWSAd0W4ojCxvpCiqioJCQm0tLR4jBnveyA9PZ3y8nLy8vIOyYUhjcMXzZjROCLwlpPsuFLo66FsMpmwWCw+XRO6GuCjpSwTC+zfv7/bVcyiicFgICsri6ysLM9K8b59+1AUhbi4OBITE4mLiwvoThOKzG+oHCpJVf3d43379uVf//oXBw4c4NFHH+Xxxx9nwYIFjBvXddJK4wXXI2/6CWXfbs97yq6tSNNPPvh3m6KZ87vPDvYlOwfHE67M8MbLbwtKDhlcOwXvvfce7777Lueccw4ffvgher0e1WHHsWY5zlVf4Fy3qs2wcp2rNGoiuumnoJ96ImJSisfwNF50A7aP3kB/9AzEfgPRH3typ8SQcDB3iysgf6dLCnnPTjJqK+ks9o4rd4vbRaygLSg/tyBoI6k78fX9y7JMY2MjTU1NOBwOzGYzSUlJZGdHJtvcsd1oixE4HI6oLsjE+u83VLxde90iAN6fucnJyWHnzp2aMaMRc2jGjMYRQ3V1NSkpKZ3e9/VADqRA1NP+wr05aOzfv5+pU6f2StuRotPpyMjIICPDlYekpaWFxsZGysvLPavISUlJ6PX6duVCkfn1RU9/X27BimjGgXV1j+fm5rJw4UJKSkp47LHHaGho4LbbbmP06NGe8h2vgWA0Ybrpb7TcOR/Ba0dCLd9/8HXlfleSzH17XG+kZmB/9TGQneimnoRuXNfujk6nk8WLF/PWW28dNGJ0OuRtv2Bd+QWONd+0xe24zlHsPxjdjN+hn/5bxKy+na6BIAgYTjsf/e/mtjsn1WpB2burLXfLLlecS6fcLWqby5gA2TnoCoa7XMTaDJhIc7d0J+5+WSwWGhsbaWlpQRTFoGSUIwmoj/b1qKqq8vncdxONmBOIDQMnGnnHdDqdX+nllJQUTxyUFjejEUtoxozGEYGqqlRXV5OZmRnU8WazmZqamm7uVXB0mhR280DiHhDdKmaR5H7obkLJ35OQkOBJ+ul0OmlsbKSsrAyHw4HJZPLIQQdjrLjdEN1/RytwOhzcuWa6S9Qi0AQpPz+fxx9/nOLiYhYuXEhrayu33XYbI0eO9Hm8VDAU04U3YHv9cc97yu5tntdy2X4yVQeoTkBAzB+EvOFHMMVjvOSWgP2UZZkPP/yQN998k9///vcud7LyfTgXv0DLqi/aZbYX0rLQHftb9DN+h1QwtMvzV+uqXbEtxbtQSna43MTK97nifzpiMLbL3SIWDKE5JQunzkBiRteKYh3b7un7yW6309TUREtLi+e3kZSURFZWVkjus72J9zOyrKzMk7/K37GRttVbdNezx71AotfrO32XRqORlpaWsKXGNTS6A82Y0ThiqKmpYdCgQUEd21GByJtoGxOhTlgCtR2NyY+7fFlZWVhBsz3t0x8O7pw1aWlpwMHV56qqKgRBwGw2Ex8fT3x8fCelq47ff2+vyBoMBmw2m98ksJESzPkVFBTw1FNPsWfPHhYuXIjVauWOO+5g2LBhnY7Vn34+zl++R978k+sNVQWDEew2lLISjlcP/u6UPTsBMMye327XxBtFUViyZAmvv/46p512Gu899zTi2hU4/3wZ9pJdB9uIT0Q/9SR0x56MNHICQofvFbxyt7iD8kt2ohRtR22uPygI4K5PEPzmbumY/8ZosdBaV9fldexINH7LXT2rbDYbTU1NtLa24nA4MBgMxMfH07dv3067locK3udcX1/PmDFjerTd7nwmdFQf6w7MZrPP5JmqqpKTk0NZWVnQC4MaGj2BZsxoHBGoqoosyyHtMiheq64d8y/4qj/cgSWaA1I0/db379/P+PHjw+rDoeCG4P2dudXRsrOzUVWV1tZWmpubqampQVEUjEYj8fHxJCQkxNwEz71S6qY33V4GDBjA008/TVFREQsXLkRRFG677TaGDBniOUYQRUzX3UvLbedDa1u/3flS6qqZRFtMmyhCQy1Cn34Yfn9hp7YUReGjjz7ilVdeYdaJJ/DOdRcj/Lgc5y2vtGW7B/Q6dBOmo5vxO3QTpiMYDsZNeHK3tCWblIt3+Mjd0mbBiCJi3zzEgmFtbmKDXblb0oKb0BmNxqCTm0YTX79Bq9VKc3MzLS0tOJ1ODAYDCQkJ7YyXwyUewmKxoNPp/CqqRfs8e+KahdpGODGAJpPJpzEjCAKZmZls2rQp5p/vGkcWmjGjcUTgzjMQykDg9h2WJCmsOIqenBB0R9Cs3W4Pe7X/UBjo/F0vdxCstxuFewLodkvT6/Ue46a3ld4MBgN1Xqv+sTAJHTRoEM888ww7d+5k4cKFiKLIggULGDx4MABiRjama/6M9bG7XQXc94uqkkKbv37bYoLpsvZB/4qi8Omnn/LqSy9xyVHDeGv6UFi7BOX7g8aCNOIodDNcgfwkJKNWleHcsMa101K8o+vcLW0xLWL+YNfrvMFh5W5xG/Ud5ZnDqSMcZFmmtbWV1tZWLBYLsix7DPPc3Fy/romxcA9Fg64kmX2d56GwEBMKoY5d7gTJtbW1nY51q53ZbLao9lFDI1I0Y0bjiKCqqorU1NSQJv1uRTN3nEWo9OSEINoS0uXl5WSE6N9/OGMymdrlVrDb7TQ3N1NZWenJ82IymTCbzcTFxUVk4IRqmOr1epxOHxK/McCQIUN47rnn+PXXX3nooYcwGo3cfvvtFBQUoD/mNzjXfINz9f/alfFeQ9cdPQPdhOmA67r857NP+e6lZzm7XwqvpbVC4UEJZ7HfAKRjfos0cDg01iGX7MCy8K6DuVt8IGRmI+YNbcvd0iaBHMXcLdFwRwx2Yu3eUWxpafEYLqIoYjKZiI+PJyMjo5PLZCwRbdlycLnKhrq73NuGTHdI+4eCIAjo9Xqf+au83dt6+zppaHijGTMaRwQWiyWo4G5v3MnDwjVmYp1A12L//v3tXIO6m0PNrcVgMLSLuVFVFavVSmtra8QGTqi7fD0xsXA6nTidThRFQVEUZFlGlmXPa+/33a+9MRgM3HnnnRQVFfGnP/2JuLg4rrjiCnJPnUfahjWIluZObao6PRUnnoNcVMSGz5bS/L+POSkejtNboaIaADk+EWd2fzCYkOqrkT5YhNAxwaWqour00DcfIX8wYsFQdAVD0Q8cipiU2m3XrCPRVJ3zvt9aW1ux2+0ewyUuLo60tLReEYSIBEVRPC6q0aov0O5yrD5zoi3t39V5hvP8EEURp9PZ67vSGhpuNGNG44igpaWlk6JNVw9xs9lMc3PnSRa4BspgM1tHm54YhFtaWkhNDX2iFw1p0EMRt2iA2WwmPT0daD/hrKqqwmazoaoqZrMZg8HgOT6Y1fJgFNZCQVEUHA4HDofDY6h4//M2RgRBQJIkTwZwURQ9r/V6PUajEUmSPP/cn/ti0KBBnHzyyWzevJlHH32U5ORk/nj5H0n8972djtWfcjbNK76ANf/lZJxgBJyAKIHeADYLUksT0u7C9gUTkhDyBqP2GwT9B6D0G4iclYsiSh4jzOl0ItfUo1a3d89zn4NOp/Ocn16vx2AwRGwc6PV6bDZbSPW43T0tFgtWqxWLxeKZ9LsN5ezs7G5XHOyJoPNo11tRUeH5LfZEe7FIMM9jf88OSZI8btYdj4+Pj6epqUlTNNOIGTRjRuOIwGKxtFuhC2byZzAY/Abt9pYhA90/CNfV1ZGYmBhW2SNhguALVVWRC9fj/OlbkBV0R01HHDMJ8fP3SOqXT/rkmZ7jbDabJwanpqbGE0uh1+s97mwmkykkoQG3W4i7jMPhwG63t/vn7TYiiiI6nQ69Xu+ZvJvNZs973X1/jxkzhldeeYWNGzdy16OPco05gzGWas/nKuD49F3yBVwKYt4/V0UGmyuXi9AnFyl/GGL+EI+rWCS5W9zGnCzLnmvoVvnyduUTRdFj5Hj/P9B3ZjQasdlsfieA3kaLzWbD4XC4ctwYDB7p8MzMzF5xFetNt6dwOXDgAAMHDvT52eHmJuXvukeyI2M2m33mWnPL3Dc0NISldqmh0R1oxozGEYHT6Ww3CQjGZSdWBuWeprS0lJycnENqwO/NvqqqivW5f+L8einoRFAFHF+8DwlJ0NyIkJSKbsRRCIkpnhV17/gbN24jp7W1lbq6Os/kWafTYTQaMRgMnv9LkuQ53mazUVVVRUNDA3FxcQiCgE6n80yw4+LiSElJwWAwHFTkUxRwOsBuQ3XYwd4KLQ5UpwPFbkN1OlGddnDYUR1OcNrBaUe1213lHA5Uh831vsPpeu1wuupy2lyfOx1tx7aVc7jKqm3lcdgZ6LTztMMObefqVj8WcP3Ho4as1yHmt8W25A9BLHAF5gtxnV1AI7kPdDqdZ+ck0MRclmWPgeg2QrwNHlEUMRgMHkPE/b3V1tai0+mw2Wye8u5dMLcxGxcXR3p6etSToMai0lZ30tTU5HED7cih8lzriL/nXLgxk4EIlDg6MTGRpibfcWgaGr2BZsxoHBF0dJNw/91VzpaOfu69MWn27mskk4Vgy1dVVTF8+PBDasDvzb46167A+c1SEFSQvWJFmhtBb8B40Q2ocYlgs7YZB67JvSA72yb2LoNCctiJdziIc0/2nXacVgu25hZsLU00t7ZQ19LSZkQ40KEgqSp6Afo5HUiqikkAQVFchoPD3mZU2HHIThxtbWO3QUdlLVVtS1Tftg2itt0nQvtj8Nw/7uvt437q+FV0ccu1S9/ieX3wv0JSKtLoSejGTkIafTRidm7A+qIVpBzotyJJksdN0Bun04ndbsdqtdLU1ERdXR0tLS2e3bH6+nry8vI8CVozMjKIi4vrtp2wjpLysWRseBPtvtXV1R2WsY7B3M/RupZGo5GGhgafnyUmJlJeXh5xGxoa0UIzZjQOezrGt3hnbu9IR/Uh7+RhPTmQeBMtX/VgyrsDiWNZ9ag7iOR7c3z3H9ck39ft4XBgff5BeObvvhr1Mg5oP6v3QgLi2v75LetVRadueB+rgoCKKggH5ZAFAfQGBL3BlYdFrwedDkFncMWmtH2GXgeSAUGnB4Ox7T096PUIej3oDKAzdHi/7T1dh/f0BtDp+WXLVl5+7TXyBg/himuvI/6T15GXfwyoqAgoCEiNdTi//wrnD1+5upvVF92oSUhjJiKNnIiYnuXjwkfXwHU6nZ4YI/cOjPu1dztuNz29Xk9aWhp9+/ZtF8+ye/duCgoKPDtqTU1NVFVVeeSb3bt2cXFx7cpFGosWC0ZMVyIW0axv//795OYGNnqj2V4sEa0+mkwmKioqfH5mNBrDlhrX0OgONGNG47DHarWGrbqSkJBAbW0tycnJQQ0Sh8JgF4iysrJOQgmxRHdNKCKq09Li2unwubquguxDNllvQNXpUCU9qk6PqtMhSHpEoxHRaEI0mECvcxkOOm+Dos0g0OnAYHIZF3o9iihR39pKenY26PRehogeWZSQBRGnIOJAQEbEKYBTFXCKIkg6Vzb7Nvc072B+f/8i3UlYu3Ytjz/+OAMHDuSvTz1LVpbLIFHn30LZ8k9JREYAJFSKMFKb3oeJqQmIxdtRK8twVH6MY/nHAIg5+Uijj0YaNRFp1ATEZN+uRYBHcc0dF+P9f0VRPP93T9Tc95vb/cxtrLiTp+r1+pBV5kRRJC4urpPKlizLHjfDiooKT4yTt/uZ2Wzu1Xi9SOiuRR5f1NTUMGrUqB5rryeJhndAMM9RURQ7qRK6yx1KLsgaRwaaMaNx2KMoiifxZagPYLPZHLUEYb2dPyAYDhw4wLhx43q83WCJxSR30siJyJvXAUqHT1TEUUejXHY7LU4Fm8OBLErojCaMbZPTuLag+1DxdX+07t5NHx8Bz8HWrqoqDofDo/jl/mez2dr97Ut62Y17ouOecLtfu/+/efNmXnjhBXJzc7nnnnvIyspCVVWqqw8G/3+gJDNfqAWjCRSZQU4bObZG7v21laQh07jy+KkkHChC2r4JcX8RSmkJSmkJjq8+BMDRJw/HoNE4Bo3EMWA4ivlgsly30pq3maTwggAAyhZJREFU0eaOL3K/FyhjfCj4i23wp4QoSVKnZK1wUBigqamJyspKFEXBaDQSFxdHfHz8IS+PG+1nXXNzM0ajsddFWrrrmRSNeoO93t7HeX9PbqUzDY1YQTNmNA573CtMkQwCkUgxhxPv0huGjFtpq7flNkOdCPT2CqHh5Dk4/vshan2tS2kLt8eYgHPPdqyCjoTsdLJCjI2ItltOV7iVsyLBnfRQVVXPb05RFDZs2MDjjz9O3759efDBB8nMzPT7va0knvm5yQilxahTTkLdXYi5qoy/xxnYlZvGzS+9xbhx47jm9kdINehgx2bUX39B2boOdW8R+vK96Mv3wvf/AVFEHDAc3eiJSKOORhoxDsHkO+9ItPH1/bkVEn0JQPjDLSSQnJzsec9ms9HS0kJVVRV2u93jEuve8emuHDPdQbTv5b1799KvX7+o1hkqvf1Migbu5Jl2u72deAj0rpqnhoYvDp0nnoZGBESyihQfH09LS4tPueJgjBR3XohYp76+nqSkpN7uxiEzEXBnXG+22LBdez/GL9/FvHktqArCuCnoRBH9yeeQnJcfVv2h3jOCIPjMC9GTeCc9lCSJjRs38uijj5KRkcHChQuDimOQ9AbiLrsFy//dhLBuBXF/fwnbBy8hr1vFkO8/4p3fzuLHoZO54YYbmDx5Mtdeey0px5wEgNJQi7x1PfLWn3Fu/hm1bC9KUSH2okL46A3Q6ZAGj3a5pI2eiDR0jCtOqJuuRUfck8NQjBlfGI1GjEZju6Stra2ttLS0eJTw3O5wiYmJIcl8H+pUVVUxbNiwqNZ5qMTL+CLcvquq6pET97XIcag8pzWODDRjRuOwx+3mEi5uTX1fxky04mhiYbAsKysjOzu7y+Nioa+9hcViobGxkdbWVlRV9ayEZ4w9Cumoo7ulzWCvt3vi4S/jeU+yZcsWFi5cSEpKCg888AD9+/cPqbxu/FSkCdOQ16/GvvQVzH98BPuy17G/9xzObz9hUvF23v/34yzfuoPLLruMadOmce2115KUnIZ4zG/QH/MbAJTqCpdhs3U98pafUKvKkX/dgPzrBvhwERiMSMPGII08Gt2YoxEHjXDFKXUTBoMham6r3giC0MlFzW6309TURFlZmScHkVtF7VDauQmFlpYWT+6kaNITz7uOv/NoPWcjqUOn07XLTxWtejU0os3h+UTT0PBCFEWP60s4D+C4uDi/qi7RIhYGhqqqKoYMGeLzs57IAB6L2O12GhsbaWlpwel0tkte2FOuFsFe71gwZgoLC1m4cCHx8fHcf//95OXlhV2X8aKbad2wFufaFchb12OcMx9p8EisT96LUryD1rsu44Tr/8pJS5bw1Vdfcckll3DsscdyzTXXeBYexIxsxONPR3/86QAoFQdwbvkZecvPyIXrUWurkDf/jLz5Z+zvAeY4pBHj0I2chDTmaIS8wYhRnPgbjUZaW1ujVl8gDAYD6enppKenA3jU0w4cOIDT6cRoNHp2bnpjN687FkW6w8XsUM7R05XLblef63Q6rFZrp/eP5AUtjdhEM2Y0DnvcMTNuo8YfgR7skRhDodIbA4U7vqE33FGieb6R1iXLMo2NjTQ3N2O32z2r2bm5uTG3mt3xXI1GIy0tLb3Sl19//ZWFCxdiMpn485//7DPzuvfvK5jvSeo/EP1vzsLx1YfYXn8C6aHX0I2dTNw/X8Py6F0oOzZj+ddtGGZfyslzr+Xkk0/mP//5DxdddBEnnHACV111FQkJCe3aErNzMWTnwklnuuJ5DpQgb/kJecs65G3rURvrkdevRl6/2tWJ+CR0I8e3qaUdjZg3KKL7y2Aw+F3p7m7crmkZGRkAnlw4+/btQ5ZlEhISSEpK6pQ7p7sI9zoGuncqKys59thjQy4XiN6atEej3a5cwbr6XKfT+XTR7m3RFQ2NjsTW6Kyh0Q24FYwiebDHxcXR2traI8HxvTF4VlVV+cyW7S3F2V1Es+5w6rLb7TQ0NNDU1IQoisTHx5OVlRXzKlEdz9VkMlFbWxtSHZEafzt37mThwoWIoshdd93l04jxbstNsG0azrsKx6ovUYq341zxGfqZsxAzsom7/zlsbzyJ4/PF2Je+hryrENNNf+P000/nd7/7HZ999hnz5s3jpJNO4qqrrvK5WyUIAlK/AqR+BXDquSiyjFqyy+WWtmU9zsJ1CC2NOH9cgfOn71xlUtKRRk5AGj0B3ahJCH37h3T9eloFKlDSTHdOG7cYQ3NzM7W1tVitVgwGA0lJSSQmJsZcsLe/693a2hrQxcxfOW2XwT/upNEdsdlsPWb0amgEg2bMaBz2iKKI0+mMaDUpISGBpqamXlf66i7Ky8vp06dPp/cP10G+tbXVswPjnrjl5+d36W4TyxMffxMPX0RqpBYVFbFw4UJUVeW2227z654YDt6/UTE5DeOcy7C9+RS2d55FN+0kBFMcgt6A6fLbkYaMxvr8P5A3r6X1T5dgvu2fSEPHMGvWLE4//XQ+/vhjzj//fE455RQuv/zygBMwUZJg4DCkgcMwzLoQVXai7P4V55Z1yIU/IxduQK2vwfHDf3H+8F9sKggZ2UijjkY3agLS6KMRs2IrR5P399vVd+2OpwHXZLWhocFjHCckJJCcnBy22l1P/G6Ki4tDjs2C6O2AdPf59cZuiCRJPp8pLS0tEYtYaGhEE82Y0TgiCHV1sWOMSHx8fLtcGN1NT0+a6+rqGDt2rGewjGbbsWAAqKpKU1MTDQ0N2O12zGYzSUlJZGdnt1u57orePg9vfE1ugp3shLtKXVxczCOPPILD4WDBggVRV43y1Tf9aXOxf/UhamUp9o/fxHje1Qc/m3EqYv4QrAvvRCktofW+azBecgv6U89FFEXOOussfv/737N06VLmzp3Laaedxvz584OaiAmSDmnIaKQho2H2pagOO/KurS6XtK3rkLdvQq2pwPndZzi/+8xVpk+uK95m1FEu4yYt0+f5xcJvwpuOfTEajZ5Epm7Xy/LychwOB/Hx8aSmpoa0c+lvdyialJeXM3z48G6puyt64ruMlipmKN+BJEk+Xaybm5t9CuJoaPQWmjGjcUTgTlYXTrIwiFxEIFR6cqLjXnnrrjYjqTcS48rtOuOWqo2PjyczM9PvRDaWJpfe+LvnfN3PbjemcAO6/V2DvXv38vDDD2OxWLjtttsYMWJEWPWH1Se9AeNFN2B99G7sH7+J/sQzETMOqu5JeYOIe/BVrM/8HeeP32B7+RHk7ZsxXXMngjkeURQ5++yzOeuss1iyZAnnnnsuv//977nkkktCm5DrDehGHIVuxFFw7pWoVgvyjs3IW37GuXUdyq5C1PIDOMoP4Ph6KQgCYm4B0phJSCOPRho5HjE5FZ1Oh91uj3k3RjeSJJGamkpqaqpnUaCiogKHw0FCQgKpqalB79h012+soaGB+Pj4qLrEBXLR6w2iZcgE43LdsUzHtltbW33u5Gto9BaaMaNxRBAfH09TU1PAPCpdDVgmkwmLxRIT0re+CNcNoaqqyhMUHGuEM4C3tLRQW1uL3W4nISGB7OzsmJg4RjsA2df70VY027dvHwsXLqSxsZEFCxYwevToqNQbKrqpJyENH4/86wZs7z6H+Yb72n0uxMVjuu1BHJ++g+3Np3B+/yWtJTswLXgQqb8rjkeSJM4991xmz57NBx98wDnnnMPs2bO56KKLwnKfEkxmdGMnoxs7GSOgtrYgb/sF59afkbesQynegXKgGOVAMY4v3ncZN/lDiB84CvuYozFMmIYQlwDExmQ5GARBICkpiaSkJFRV9ezYOJ1Oj2ETqohINM69pKQkIuU8X4Tiohdr+Lum4YwRvuSiLRYLCQkJEfdTQyNaCCHc2Jp0hcYhyy+//IJOp+vSpzrQwNrS0kJjYyN9+8aWX3y4uM9106ZNZGdnB5VjJlA90epPOFitVurq6mhpacFsNpOWlnbIBKhGcyJbU1ODKIqkpqZGVM+BAwdYuHAhtbW1LFiwgLFjx3o+6+6J9/nnn8+7777b6X155xZa774cgLh/voo0aKTP8s7C9VifuAe1tgpMZkzX3Yt+2kmdj3M6Wbx4Me+88w7nnHMO8+bNi6qan9pUj7Nwg0stbes6lH1FgNd1EyXEQSPQjZ6INOpopGFjEUyB79lYVZFyGzb19fXIskxiYiKpqak9pgD4zTffMHPmzF41OmLhORjtugVBYOfOnQwePLjd+6tXr2bmzJla3IxGT9HlTasZMxpHBLt376asrIxRo0Z53vM1MehqslBUVMSgQYPavXeorKr649tvv+W4444L2kUjViZUTqeTmpoaTxB/amrqEb9a2NzcTHNzc9guIGVlZTz22GOUl5dz6623ctRRR0W5h13jz5gBsDxxL85VXyCNnID5r8/6/d0ptVVYn7wXecs6EEA/6wKM827wmRDT4XDw7rvvsnjxYubOncvcuXPbGTXR+n0rtVXIhb9g3bAGpXAdYlUZrmG1rW5dW4zOqKORxhyNNGQ0gj68gPuewJ/rrqIoNDQ0UF9f7zGsA+2Ih9u2+xlUXV1NSUkJEydO7HTc4SynD8HJnYcSE+iLPXv2kJeX1851dcWKFZx55plh1aehEQZd/rg0NzONI4Lk5GSKioo8D/xA+WQCodfrsdls7dyWDmVDxi0TG4qvebQCUcOlsbGRuro6VFUlNTWVrKysmPoOetO4DUeeGaCiooLHHnuM/fv3c8stt3D00UdHvW/RMIKN867D8eM3yFvX4fxxOfqpJ/o8TkzLxHzPU9je+jeOT97C8ck7KLu2Ybr5AcT0rHbH6vV6Lr74YubOncvbb7/NnDlzuOCCCzjvvPPQ6XRR+y7FtEzEY0+GKTMpLS2lv9mAXLgO55b1yFt/Qq2uQN62AXnbBvjgJTCakIaNdamljZ6IOGgEghQ7Q7a/mBK3AZOamorD4aCmpobKykoSEhJIS0sLz6Wvw73j/XrPnj2dFpi8yx3OBCN3HmisC+b66PV6nE5nryRW1dAIlth5MmpodCOJiYm0tLR4gh9D3Wp3DwjJycnU19eH5ZIVymSup3Y/qqurQ3ZJ6g1XCofDQW1tLU1NTSQkJJCTkxMVl6BoGh69qVLlblen04WUlLGiooInn3yS4uJibrrpJqZMmdKtfYwUMbMPxt9fhP3Dl7G99RS6icf63b0QJB3Gi29CGjoG6zN/R962gdY/XYrplgfQje68im8wGJg/fz4XXHABb775JnPmzOHCCy/knHPOiepETq/XI8syYlZfxKwz0J9whktcpHwfzi0/I29Zj1y4DrW+BnnTWuRNa7EDmOORRo5HN2oS0uiJiPlDEDosQoQatB6t+9VfHXq93rNL2NTURFlZGYqikJKSQkpKStBt+xNfURSF5uZmnzmyugtf/Qj1GsbCbn6w7bufKe4FvPr6epKTk7uzaxoaIaMZMxpHBO4VVu9dBX8DSscJgTdJSUnU1NQELB8NesqNq6qqyiPB2pMEe90aGxs9Ow3dsQsTbQnq3iLUYOWqqiqefPJJtm/fzi233MIxxxzTnd2LGO/fmuHMi3F887FLOeyLDzDMmue3nCAI6KeeiJQ3GMsjf0LZV4Tl7zdgnHcd+t9f5PNaGQwGrrjiCi688EJeffVVzjrrLC655BLmzJnTbavTgiAg9M3D0DcPfjsHVVVR9u12SUBv+Rln4XpobkRetwp53feuQonJ6Ea68ttIo45G7FcQ8n3QkxNqdx4bWZapra1l9+7dmEwmMjIyghLo8NXX/fv397iqVsd+hDoOhHJ8LBg9kiShKIrn78rKyl4ZMzQ0AqHFzGgcMSxfvpzc3NwuH8RdDSAlJSXk5ub2WHBrd7Jy5UqmTp0a1cDnSJFlmerqas8uTHp6ekz1L9YJdH/W1NTw9NNPs3XrVm666SaOPfbYqLYdjclXoJgZN45vPsL67AMQl0j8kx8iJqf6bLvdwoS1FesL/8S58gsAdJNPwHTdPQjxgfNlWCwWXn75Zb788kvmz5/PWWedFdYOrze7d+9m4MCBQR+vyjLK3p3Im9fh3PqTyxXN0truGCE1A2nkRKQxE9GNmoiQ3a/XJ8Jd0draSnV1NYqikJ6eHnLuklWrVjFx4sRDRuzjUKSqqgqDweDZjVm9ejWTJ08mPT29l3umcQShCQBoaLj59ddfKS8vZ/z48RHVU1tbi6qqPfYw706Xs2+//ZYTTjgh5HLd0Se73U5lZSV2u5309HSSkpJifjIWi1RUVBAXF9duYlhbW8szzzzDhg0buOmmm5gxY0ZMXVtvw2Du3Lm89957gY+XZVr/dAlKyU70p56L6Yo7gm7H8dWH2F59FJxOhD79Md/xEFLe4C7Ltra2smjRIv773/9yxRVXMGvWrLDzmuzdu5ecnJywF0RUpwNl9684N/+MvOVn5B2bwG5rd4yQ2ccTbyONOrpdbp5YWPH3xuFwUF1dTWtrKykpKaSlpXXZP6vVyk8//cSMGTN6qJeHL4Ge597GjKqqLF++nNNOO01TMtPoSTRjRkPDTX19fciTd1+DvizL7Nu3j4KCgrD7EguTiaamJrZu3crUqVN7tR+tra1UVVUBkJGRQXx8fK/251CnoaEBu91OZmYm9fX1PPvss/z888/ccMMNnHDCCb1+33VFMDszAM7Na7H87QYQJeIWvoPUryDoNuSdW7A8dhdqVQUYTZiuvhP9cacFVbalpYUXX3yR5cuXc9VVV3H66aeHfE1LS0tJTU2N2o6C6rB7EnjKW9e7jBtZbieWJvTpj2700W1uaRMQU3p3Zd3XBFpRFGpraz1JMDMyMvwafNu2bSM+Pj7q+WUCEStKjj2FqqrU1NSg1+tJTk6mtbWVTZs2cdJJJ2m75Ro9iWbMaGi4aW5u5uuvv2b69Oldroh2ZWzs2bOH/Pz8qGacDqcfkVBcXIwsy36VgLqbhoYGampqMBgMZGZmxkRiy2jSWwarzWZj9+7dfPzxx/z4449cd911nHTSSTFvxLgJ1pgBsDx0G86fVyJNPJa4Ox8NqR2loQ7r0/cib/gRAP3JZ2OcfyuC3hDUd9fU1MQLL7zAypUrueaaazj11FODvsYdXXeijWptRf51E3Lhzzg3r0PZvQ284h4AhH4D0Y1xGTe6EUchJHZvUHeov4fGxkaqq6vR6XRkZWV12gn45ptvOP744zWVrW7CHWNaU1ODTqcjJSWF3bt3oygK48aN04wZjZ5EM2Y0NNxYLBY2bNhAQkJCl8kzA6GqarvJyKEySezIzz//zODBg0lJSYm4rmAnKu6VvoaGBhISEsjIyNAmI1GkqamJ5557jm+++YZbbrmFk08++ZC7P0MxZpQDJbTcdgHITsx/eQrduPZqbF3dl6osY//gJewfLAJAHDwK863/QMwKPjFuY2Mjzz//PD/88AN/+MMf+O1vf9vlNa+vr8fpdJKRkRF0O5GgtjQhF27AWfgz8uafUUp2tj9AEBALhrXF2xyNNHw8Qlxs7JBarVYqKytRVZWsrCzMZnPA3DKHA7G0A+Q2KFNSUli9ejWjRo0iNzdXe25r9CSaMaOh4cZqtVJeXs7OnTuZPHlyRIOF3W6nvLy8R10c/BHuwLd8+fKI3I7cbQZrxNTW1lJXV0dKSgrp6endOsmOBTe+nkJVVVpaWnjhhRdYsWIF11xzDcOGDeu1HbdICcWYAbC+8giO/yxGzBtM3L/eQAhjkuVctwrL03+F5kaEpBRMN/4N3fjQ3C/r6+t57rnnWLt2Lddffz0nnnii33uwtbWVhoYG+vYN3mjyRbi/faWhDnnbLy63tM0/o5QWtz9AlBAHj3LF24yeiDR0LIKxd2MkbDYbFRUVqKrK3r17GTNmTFQWYjQCU1NTgyRJJCUl8e2333LiiSeSlJTU7V4JGhpeaMaMhoYbp9NJU1MTX3/9Nb/97W+DmgQEmhQXFRUxcODAqE+ae2JVTpZlVq1axfHHHx9y2VClRevq6qitrSU5OZmMjIxezccSCuH2sSfPrbW1lZdeeomvv/6aK6+8kjPOOANBECguLiYvL69XJhyBjNxg7u1QjRm1sZ7mm8+G5iaM19yF4Tez2/Ul2O9CqSjF8uhdLpcswHDeNRjOvqxTLpeuqKur49lnn2XdunXcdNNNHHfccZ364HA4KC0tJT8/P6S6AxHJfafUVCJvW+9SS9vyE2plafsD9AakoWORRk1wGTeDR/nN7xOtfvm7V1paWvj000+ZOnWqZ6dGo/uoqalBFEWamppoaWlh5MiRWp4ZjZ5GM2Y0NNzIskxTUxObNm0iIyODnJyciOqrqKjAbDaTlJTU5bGxNnmvrq5m3759HHXUUd3WRl1dHTU1NSQlJZGRkeGZWHensdaTiQID1d3dbVitVhYtWsRXX33F5Zdfzu9///t2hktZWRnJycnExcWFVG8s3KOhGjMA9k/fwfbaYwgp6cQ/8UHYLlKKzYr9lUdxfL0MAGnCNMw33I+QmBJyXTU1Nfz73/9m8+bNHgU57/ujuLiYAQMGxMx190apKPXE28iF61BrKl0fuAUFjGakEeM8amnigOFh7YiFw65duxAEgX79+lFeXg4Q80ZNKN9xLLmYwUFjZsuWLUyaNAmz2awZMxo9jWbMaGi4UVWVhoYGmpqa2LhxY8Q5NpxOJ/v27WPAgAF+24u1SYqbnTt3YjQao+Ym532u9fX11NTUkJCQQGZmpuaOEEWsViuvvvoq//nPf7j00kuZPXu2z+vrTjTaVWb0WLxHwzFmVIedlgXno5bvxzB7PsZ510XUB8fyj7G++C9w2BGy+mK+9UGkwSPDqqu6upqnn36abdu2cfPNN3sSlIaaa6a3UFUVtWwfzi1rkTevQy5cj9pY1/6g+ER0I8YjjXIJCoh5g0Le0QqWb7/9lunTp3sC0N0uv6qq0rdvXwyG4HaMIiEWfzfdRU1NDQ6Hg507dzJjxgwkSQo5H5CGRoRoxoyGhjeNjY0oisJ3333H5MmTI9bK37NnD/3794/5BJodB98ff/yRkSNHBjUoBTtwNzc3U1FR4TOwPxYG/1joQ7jYbDZef/11PvnkEy6++OIus9FHKyajNwjHmAFwrP0W68N/BL2B+McXI2ZFtvMq7/4Vy8K7UCsPgE6H8co/oj/xzINJOEO8nyorK3nyyScpKirilltuITMzs9eMmUh+C6qioOzfjbz5Z+StP+Ms/AVamtodIySlIo04CnHURPRjJyHk5Eflt1dXV9cu5tG7TndMpMFgIDs7O6gA9Z7eBYn2M6gnnmm1tbXs2rWLPn36kJeXh8FgCGnHV0MjCmjGjIaGN01NTZ48MU1NTYwcGd5qq5uGhgasVivZ2dldH9xL+BrwVqxYEVa8jC/sdjtlZWWIokjfvn1j3rALhd42gOx2O2+++SbLli1j3rx5nHPOOUFdX0VR2Lt3b0S5kHqLcI0ZVVWx/PU65MJ16I49GfPNDwCRTVjV5kYsT9+PvG4lALqZszBdcUdEwfAVFRU88cQTFBYWcvfddzNp0qRD1sgGlyKcUrwdecs6nFt/Qt62EayWtg9xTUPSMpFGTEA/5mik0ZMQs8MzNNeuXcvgwYNJS0vz69LZ2NhIVVWVx731UL62sUBtbS3fffedx5VVM2Y0egHNmNHQ8Ka1tRW73Y6iKCxfvpyTTjopovpUVWX37t2HlHKUqqqsWLEipOShvlAUhYqKCiwWC3379g3LZ723jYVYxeFw8Pbbb/Phhx8yd+5c5s6dG7KR2J1uTN35vYVrzIBrN6X1zktBVYl7YBHSsDER90dVFOzLXsf+3nOgKIj5QzDf/k/EPuHLuwOsW7eOt99+m4qKChYsWMCECRMi7mssoDrsyEWFyFvWu9TSdmwCh73dMUJWX3QjJ7mkoEcfjZCW2WW9DoeDH374odMijK970S0BX19fT1ZWVlBxjb1NrDwLOxr/O3bsoKioiN/97ncAmEymiD0aNDRCRDNmNDS8sVgs2Gw2ADZt2kRmZmbErjilpaUkJye3y1wfKwOTL+rq6ti9e3dEORrcwf0ZGRmHvDxqLH1X3kbMueeey/nnnx92cro9e/ZQUFAQM+cWLJEYMwCWf/8N57efIg4ZQ9z/vRS183du+hHrk/ehNtRCfCLm6/+KbtKMsOurqKggPj6exsZGHn30Uaqqqrjlllu6VZSjN1DtNuTtm1w7N1t+RikqBNkJqgqCACqIuflIo49GGjURadQExOTOsV7bt2/HaDSGtNsoyzKVlZVYrVb69OkT0yIBkRLoORbqM877+P/85z8MGjSIYcOGARAfH68lzNToaTRjRkPDG5vNRmtrK4Ig0NzczMaNG5k+fXpEdVqtVqqqqiJKxAn+VxhDnYx1VaaoqAhRFP0KFwTCYrFQVlZGXFwcWVlZWnB/FFBVFVmWWbx4Me+++y6zZ8/mwgsvjDiQ+cCBA6Snpx9yq6iRGjNKTSUtN58LNgumW/8P/TG/jVrflOoKLI/djbJjMwCG2ZdimHsNghS6a2VHkYZ9+/bx6KOPUl9fz4IFCxgzJvJdpWgQ9TgPSwvyto1tCTzXoez51WXYuOcigoCYPwRp9ATX7s3I8QgJSXzzzTeccMIJYT1z3K6wer2ePn36eOqIpYUMX/SGspn3NWlsbPTs4icmJiIIAvHx8YeVK7HGIYFmzGhoeONwOGhpafH8vXr1aoYNG9al6pMvvAea3bt3U1BQENHkvuPA2l0D7bp16xg4cCCpqalBl1EUhbKyMhwOBzk5OT2iGBRtYnHiIssyH3zwAW+99RZnnnkmF110EUajMSp1uyVVu/qeu8NgjoRIjRkA2/svYX/vBYTsvsQ/thjBEJ1rCi43KtsbT+L4fDEA0pijMd30d8SU9JDqaWpqorW1tVO83d69e3nkkUdoaWlhwYIFjBo1Kmp9j0XUpgac2zYgb/0JedM6lP1F7Q8QReR+g2jMGUTOib9DGjEOwXQwZiOUCX9DQwNVVVVkZ2cfEopckeyoRIM1a9aQlJREQUEBcXFxCIJAUlJSzD1HNQ57NGNGQ8Mbp9NJc3MzcDBz+oYNGyKWaa6urkYUxbCMop7m22+/9UhsBkNzczPl5eVkZmYGlV8g1ibHsYgsyyxZsoQ33niDM844g0suuSTqOyg9pWgW7e8uGsaMam2l5eZzUWqqMF54HcbZ86PTOS8cq77E+tw/wGZBSMvCvOAfSMPGBl3eZrNRXV1Nbm6uz8+Li4tZuHAhVquV2267jeHDh0er61El2t+/Ul+DXLgOefN6nFt/Ri3b2/4AnQ5p8Oj/Z++8w9yozv3/nRl1aVdbtNreXXA3GGyMDcYkuaTys+kh9NBDIJRAAsklN7mX3CSYFkghDUJCKKHdkIRwc4MNtgEXsHFv25t2Vyutepny+2MzE0mrMiONytrn8zz77K5m5pwzZ2Y073veBmb+KWAWnQpmziJFyirHcRgeHgbP82hoaADDMKovIuXr+0yO4pZun3QFbRPxeDzYs2cPWltbYbfbpQWsme5WTJiREGWGQIiF53l4PJ64l8327dvR3NyMurq6rNvlOA69vb2qBFznW7AXM5ll6ofneQwNDYHneTQ2NspWfopNKStGPM/jtddew9NPP43PfOYzuPrqq/Pmx69mRrNCzqkaygwARDe+gdCT3wWMJpgff1mx5UQOXN8xhDZ8A/xg71T65itvh/YzF6edK3EuxayKma5PV1cXHnroIXAch7vuugtz5sxR+SyUo0Qoltteqra8fV3oe+t/0BHxgtuzDcK4A1KaNEEA9AYwcxaCWXAaNItOBd05D5RmekxHYh9+vx/Dw8Oorq7Oi/VypvP+++9jzpw58Hg8UvkBhmFgsViKPTTCiUfGh484PhJOKGKr0IssWrQI7733Xk7KjPhFH4lEcnbBomlattuE0pdsJBJJOgeJeL1ejIyMoLa2dkZkAopFjiCpFnLb43kef/rTn/CrX/0K//Zv/4bnn38+7+lNaZoGz/OqtDUTBTnmzM+A/utL4LsOIPLSL2C4/htZtZPuGjMtnTB9/2mEnvwe2G3/QOg3G8Ad3gPDjd8EZTQnPUZsi2EYWdeno6MDP/nJT3D06FFs2LABPM/jnnvuQUdHh+zrovZ9r/b9kK69I+NuNHz+Uhjr6qYKeDoGwe7bOZUpbe9OCO5xcHt3gtu7E5EXABhNYOYtmYq3WbgMdNscUDHWF3EuzGYzOjs74XA40N3djcbGxpTf3cV09SoUibEyLMuiqqoKbrcbDMNAEAQSI0koWYhlhnDC4fV6wfN8nMLw8ccfo7KyMqcgfq/XC5/PV/BChUpeng6HAw6HA4sXJ3eH4TgOQ0NDoCgK9fX1JW+NKaTgkK373BtvvIFf/vKXOOecc3DdddfFZb1Tm8Qxdnd3o7W1dUYJIWpZZgCA3f8hgg/cBNA0TD/6PZiW3FKop7oHBEFA9I3nEf7djwGeBd3UDsNdPwDT1Ja2re7ubsXW3IMHD+KRRx4BwzD4+te/nlUij5kCy7J49913sXbt2qTbeZ6HMNQHbu/2qWxp+3cC3sn4nczl0Cw4+Z+Z0k4D0zr9HgiFQhgcHERlZWVaV+GZqqjIRTw/0SpTVVUVl+LdaDSqFtNHICiAuJkRCIkEAgGEw+G4l1IkEpFemqkEPzkvsqNHj6Kzs7NkX3iHDx+GwWBAS0vLtG1ibEyy4FiKosDzfEmeV74EjJyqpAsC3nzzTfz85z/HmWeeiRtvvLEo7hlDQ0OorKzMe0paNa9BojKTa9vBH90DdttGMEtPh+n+x9UYYkrYAx8h9Oi3IEyMAUYTDDd9C9ozPply/1xqAe3fvx+PPPIIDAYD7r77brS2tmY77IKQzXU8dOgQdDqdbIVN4HnwfUfB7dkBdt8OcPs/AoL+mB0EUBU2MAtOAbPglKkaN/UtUpzJyMgIotEompqa4izkqcZdjGxj6VDjOZyYmMCBAwewatWqaQq3xWIhmcwIxYAoMwRCIuFwGMFgcNrnBw4cgE6ny6kA5vj4OADAZrMpOq5QK37bt2/HnDlzpgXyOxwOhEIhNDU1JbXG5CrYF8K3vhQQBAH/+7//i5/+9KdYtWoVbrjhhqzd9ERBKZdzTkz/W2zknIualhkA4If74L/zUoBlYfzmo9CccoZqbSftb2IMocf/Hdy+nQAA7ee/CP2Xbk0ax9HV1YX29vac7um9e/fi4YcfRllZGe66666kCxWlTLp7Ipd0zAAgcCz4roNg9+wAu287+EN7gHAobh+quhbMgmXQLFwGZsGp8BstcDgcaGhoUNUVtFS+QzPx9ttvY8WKFdK5iwq3IAiwWq0zyspLOG4gygyBkEhsRrNYeJ7H22+/jTPPPBM6nU7xqpu479GjRzF79mzVxqsmb7/9NtasWSO9kFiWRX9/P8rKyhQrYIR/IQgC/vGPf+DJJ5/EihUrcNNNN8nK/JZvgsEgXC4XGhoaij0U2aitzABA6LePIvqn50A3tcP00O+zqguTiqT1oTgWkT/8FJHXnwUAMPOWwnD7f4Kutsft19fXh/r6elWKEH788cd4+OGHUVlZibvuugtNTU1Zt1UKiwYDAwNwuVyq1tsRohFwR/aC27cT3L4PwR36GGCj/9w4VcSTqmsEPW8Z3HXtYBafitpZc1XrP6sxy7wWSt5Xqdo8dOgQAEgFMoF46yHJZEYoEiQBAIGQiOg+IH6Ziy8BmqaxaNEifPjhhzj99NMVuw+I7ZWXl2NychJWq7UkhIJYaJqWFBnRrayxsTFvbkildv6xqJWCddOmTXjiiSewbNky/PrXvy6pF77BYEA4HC72MCSKdT/oz78W7Ka/gB/oRvTvr0F37oWqtZ3sfChGA/3lXwU9exFCP/kuuAO7EPjGVTB87T+hWbBM2k+r1YJlWVWUmcWLF+Ppp5/GRx99hG9+85uoq6vDHXfckZUimxgsXwy6urqwfPnypNuyHRel1UEz/xRo5p8CXAQIoSC4Qx+D27sD0X07IRw7AGFkENzIICwCQP0BcNkboV+6HNqFp0Oz4GRQ5RWqjEX2mBUkecilTZ/Ph8HBQZxzzjnSZxzHSe8L4l5GKGXI3Uk44RAFevHLP/YlYLfb0d/fj76+vozuGqlWwmw2G3p7e2G1WktKkI/NnORwOBAMBtHe3p7XIP9SOv9Ech3b5s2b8dhjj2HJkiV46qmnSsaVK5Zi+fSnEvDyWb8j3TbKUg7dhdch/OuHEHnxF9CuPheUOf9FE7UrzgbT3IHgQ/eC7z+G4Hdvhf6yW6A973JQFAWGYRCNRlVdTDj55JPx7LPPYseOHbjnnnvQ2NiIO+64I6tsjcV6fsfHx2EwGFLWXlKrjhVlMEKzZAU0S1ZAD0AI+MDt3zUVb7NvB/ieI9CMDoB7axDcW68CFAW6dTaYRcumsqXNXwrKZEnbR6kjjvujjz7CKaecErdNVGbEe5VAKFWImxnhhMTn84Fl2aTbWJbFxo0bsXr16qwLGQ4MDKCqqirv6XeV4Ha7cejQIdjtdpSVlaG6unpGvnyLzZYtW/D4449j/vz5+MpXvpLWPa8UBJyenh60tLSk9XVXMs58n5OabmaxYxXYKAJ3XQZ+qBe6866A/oqvqtKHrHGEAgg99QOw7/4VAKBZfjYMt3wb7ggLnudRXa1+DRyRbdu24bHHHkNraytuv/121NbW5q0vtdi6dSsWLVo0LRFJoZDi1bxusPt3gd2zDaFd70PjGIjfkaZBd86X4m2YuYtBGTIrpmrX6cmV3t5eTE5OTstyGVt412Qy5Vx2gEDIEhIzQyAkIxgMIhQKpXyZjI6O4ujRozjjjOyChSORCIaHhwuaYSiTkNnV1YWuri6cccYZBVWysk1pXCovepH3338fjz32GGbPno1bb70Vdvu/4h9KcbwiIyMjKCsry5gSulTOIR8xMyLsjs0I/uBOQKOF+ZEXQNdlH1eiFEEQEP3flxH69cOguCioumYIN/87AtX1BVEwxPt31qxZuO2221BTU6Na22reO16vFx9//DFWrVqlSntqIQgCRg7tB31kD8oHu8Dt2w5hZFDcCFAUoNGAmb1wSrFZdCqY2QtBaUtXARAEAdFoNGUmT5fLBZ7nYbPZUFZWRoL/CcWCKDMEQjIikQh8Pl/aL+edO3eiuro6aYVuOS/v3t5e1NXVlURefp/Phy1btuCkk06KU7CyXSFUS3gpVBHLXNytxJXttrY23HbbbSWzsi33nNxuN6LRKGpqakpGYUlHPpUZQRAQ/M+vgvt4GzSnfwLGu76fl37SwR3ei+DD90JwjgE6AwIX3YTadZelPUbNBQHRsjhv3jzceuutqif+yPUe2759O9ra2lRVtjKh5PvB6XTC4/GgpaUFlHMU3N4dYPd/CG7fDghjjnixS28AM3cxmAWnQrNwGejOeaomn8gVQRDw/vvvo6OjA3X/LEoai8PhgNlsRnl5+Ywrnkw4riDKDIGQDI7j4PF40r50xexmq1atysrdLBAIYGJiImVWoUwvfbUEz4mJCXg8HgwPD2PRokVFqXcS5+6j8LyKJYDv3LkTjzzySE4xB4Ug0/xEIhGMjIzMmJS9+VRmAIDrO4rA1y8HeB7G7z0FzUlLVWlXyX3KT7oQeuLfwe36AACg/bfzob/6zoKu4r/77rt4/PHHsXjxYnzlK18piZivUCiEDz74AGvWrJm2rZQUcb/fj+HhYTQ3N0uLVYIgQBjpB7t3B7i9O8Ht2wlhciL+QIMZzIKl0Cw4FczCU0G3zgaVkJCmkBw5cgR+vx9Lly6VPotV7Hp7e6UU1fks9ksgZIAoMwRCKjweT1xQfDLGxsZw6NAhrF69Oqs+urq60NLSoigTjJovtuHhYXAch8bGRmzatAlr1qwpGYEgV/IlAOzatQsPP/wwamtrs84GlS+yVQpzKc5YaPKtzABA6GffR/T/XgU9az5M//VrUDLdZ9TKgEdRFASOQ+SPv0Tkj78CANCzFsB4x4Og7fU5ta90LBs3bpSy8d18882orKwsSL/J5vHjjz9GVVVV1gtAhSQSiaCvry9pkWFgaqx8/zFJsWH37QT83n9uBEAJQJkVmvnLphSb+aeAae4o2PmNj49j//79OOusswAkr2t17NgxdHZ2pk3GQCAUAJKamUBIBcMwGZWZmpoauN1u7Nq1K271Si7V1dVwOp2KXJPUct/q7++HwWBAfX291G4xBQG1BRG1z0Ws01FVVYUHH3wwpzod+SL2nEtFqFOCnHugENnXdBdfh+jWv4E/uh/slr9Be+ZnZB2nxpxLKeEZBvpLbsSopRoVL/0U/NF9CHzzKhhu/Q9oTl4p7Z9PAZ6iKKxduxZr167F//3f/+Haa6/FihUrcPPNN8uqk6Sm+1s0GsXY2Ni0IPTE8eYLpS63Op0OHR0d6O3tBcdx01KyUxQFpmUWmJZZwGcvgcBx4HuPTCk3e7eBPbgb8HrAfvA22A/enjqmonoq3mbhVBFPqrZJUjLUPPdQKIRdu3bFLdIlO3/xb5KWmVDqEMsM4YQlFAohHA6nFZ7EF8n27dtht9uleBMlPtZHjx5FR0eHrOBJNV5aPM+jt7cXVVVVcQLJ22+/jbVr1ypur5RWQ+WgdLz79u3DQw89hPLy8rQV1GfaPMQyMDCAmpqatPFbpXJ+hbDMAED45d8g8vxPQdlqYX7kRVlZqPJBV1cX2swGBB/+Jvhj+wGahu6i66G74FrZFiO1EAQBb731Fn76059i1apVuPHGG9PGSqh5z+zfvx9ms7mgSVPUQBAE9PX1oaysTJGrnsBGwR87AHbvTnD7dkwV8IyE8U+zDQCAqqkDs2DZv9zSbP9aFMtWkRQEAe+++y4WLFiQNl6K4zj09vaio6OjpGpnEU5IiJsZgZAKlmXh8/lkvRR4npf1AkjGxMQEWJaNy36VC+kUKZ7n0dPTg5qamjjXh1AohA8//DDr7GzFJF9C9oEDB/DQQw/BZDLh7rvvnnFClBKcTidomi6IC1GuFEqZEcIh+O+4GMLYCHSX3AT9hdfmvc9kiC6AQiSM8G8eRvTvrwIAmFNWwnjrf4Aqqyj4mARBwJtvvomf/exnOPPMM3HTTTflNdaOZVls2rQJ55xzTlbPeq7fEdkcH/s9LFrCTSZT1gkVhEgY3JG9YPdsB79vJ7jDewGem9qGKWmOqmuGZuGp0CyackujK5Sn9N61axcsFgtmzZqVdr9AIAC3242WlpaixFkSCDEQZYZASIfL5ZL9EguFQtiyZQtWrlypKLWxIAg4duyYKgUq07lCiIqM3W6f9vIZHx/H4OAglixZklP/csdY7BX+dGM4dOgQNmzYAK1Wi7vuumvGxJLkQmy9iEKR7BrIuTcuueQSvPDCC4qOkdN3MqKb/4bQY98G9AaYH38ZdFXhMmiJ9Pb2oqmpSfpuiL79J4R++UMgEgZVUwfjXT8A0zkv6bH5LooqCAL+/Oc/46mnnsLatWtxww03qB4ILggCDh06JLltFQO15rG/vx96vV6VhSshFAB38GNw+3aA3bMTfPcB4J9u0WLIDd3SCWbhKWAWngbNvJNBlaV3DRzc/HcMasuwfMWKjP2LaZkbGxtJvAyh2BBlhkBIh8/nQzQalS0sTUxMYPfu3VizZo2inPuTk5MIBoMpM2Ll+jIVXQKSKTIA0NfXh0gkknE1LhtKJTtZpnaPHDmCDRs2gKZp3HnnnXmZi1JFEAT09PSgvb097T7FVkKBwllmgKlzDtx/LfjDe6D9xDoYbv5WQfqNZWBgAHa7Pa4gIdd9CMEN34DgGAQYDfRf/jq0n1wHIHVMRz6vH8/z+NOf/oRf/epX+OQnP4nrrrsOZrNZFQWA4zhs3LgxaZ2Tmcjg4CA0Go3qKdwFvxfc/l1g924Dt+9D8L2H/6nV/POaUxTo1rlgFi+DZv6pYOYtBWX6l+Lpfn8jmIfuAT13MfRfugWa+aek7W94eBjl5eWw2+3QarWqnguBoBCizBAI6QiFQgiFQoqO6e/vx+DgIE4//XQAmYUIUVHJJrOZHDIpMsCUP3plZWVBV+aB/K8cy+n72LFj2LBhAziOw1133YU5c+YUZTwihVIaEvuJzWhWKopLMgqpzAAAd+hjBL51HUBRMP3wWTBthb0/hoeHYbVap1l7BZ8HwSf+A9zOdwEAmrVfgOHLXwell7dKno9rzPM8XnvtNTz99NP49Kc/jWuuuQZGY26xRkePHgUA1RYXSuHeHh4eBoC8ft/yky5w+3f+M6HATvBDPVMbxAKeFA169kJoFi5DpHMBerZsQtu2t4BoCAAF5uQV0F96M5jO+VKbAs9DmJwAZTSjf3QM9fX1Ba33QyCkgCgzBEI6WJaF3++XJXDHCuZ79+4FTdOYP39+2mOkNKyCAL/fj8nJSTQ2NqoydmBKkenp6UFdXV1a94+dO3eio6MjZcxEKQgAatPT04OHHnoIwWAQd911V8ZrBRRmHoo11729vWhsbEyrTJfCfVBoZQYAgo/cB3br38EsOhXGbz+Z9zmgKAo8z4OiKIyOjsJgMCQNtBd4HpHXnkXkhZ8CPA+6dTaMd/836LrmvI4vExzH4ZVXXsEzzzyD8847D1deeWVWrkhiLa+zzz47ZxdcNVBz8WV4eBg0TSe10ORF0XSOgtu3E9zeD8Hu3Q5hbCi+T40WdNtJoAQOfNdBQJhyWdOsWAvdRdeBP7Yf4Zd+AWF8FJSGQWDJKtTf/h8oq1fvfUUgZAlRZgiETExOTmb1Atu5cycsFgvmzp0r+5ju7m40NjbGuZTEouQlJwgCuru7UVtbm9GPfcuWLTjttNNS9ns80dfXhw0bNsDn8+GOO+7AwoULiz2kksDhcMBkMiWtiVFIMt3jxVBmeMcQ/HdcDEQjMN6zAZrTzsy6LaWC6sTEVGHFdJmw2I+3IfT4v08VYTSXwfiV7+Q0RrXgOA5//OMf8bvf/Q7r1q3D5ZdfnjZjXiJHjhwBAMyePTtfQ1QVpddWzHJWjMQbvGMI4d3vw7HpLVSN9YFyjf/TagMAFEAzUoIB8DwgufgJU3qOhoapcz6qn3i54Fn1CIQEMj505A4lnPDIdftKfIktW7YMk5OT0gtZDrW1tRgZGZHdRzr6+vpQXV0tKyA3Go0e94rMwMAA7rjjDjzwwAP48pe/jF/96lfHlSITq3DLUb4T9zEajQgEAqqPSynZBPPnG7q2AbrPXwoACD37GAQ2mvWYlJ6fRqMBy7Jp+9AsXg7Tfz8Des5iwO9F8Id3IfzckxC46ccVEoZhcMkll+DVV1+F0WjEhRdeiKeffhqRSCTjsTzPo6+vD52dnQUYqTr3kdJr29zcjMnJSXi9XtXalAtfbccHuiqYbv8utCctBbN0JZjZC0HZGwGt/l+KTGzczT//pyiAYnnQXfvB7XovL+MjENSEKDOEEx4xuDFZ5qV0/wPAaaedBqfTiWPHjsnqy2QyQRAExXE6iYyMjMBoNMoqbHe8MzQ0hK9//eu4//77cdVVV+E3v/lN2sJ7cii2q1UylBbMTNzHZDIhHA6rPq58ozS5RLbH69ZdDaq8EsJwH6JvvaLamDKh0WjAcVzGPmhbLUzf+Qm0n70YABB59RkE/+s28G6ntE+x4tM0Gg0uu+wyvPLKK9BoNLjgggvw7LPPIhqNphzT0aNH0draWrCg/2I80xRFoaWlBaOjowgGg0n3ycc143keW7duxdy5c2G326cKc370Hrij+yCMDgHRmO8BCnHKjFRcmRKg0WjBHd6j+vgIBLUhygzhhEej0UAQBPD/THuZidjaAhRF4fTTT8fo6Ci6u7tlHV9XV5fWOpMJp9Opat2amcrIyAjuvfde3Hvvvbj00kvxzDPPYOnSpVm3p9TyMdNIZQHIhVKbp2QCq9wxUiYLdJfeAAAI//GXELyTqo4tFQzDJFVmkkFpdTBcczcMt/8nYDCC27MDgXuvBHdwN7gxB4LfuxXstndyHlO211Wr1eLyyy/Hyy+/DJ7ncf755+O5556bdt9xHIf+/v6ipWIu5H1L0zRaW1sxODgoy2KVKzzP47333kNbWxvq6+shCAL0X74Hhi/fDf3lX4XukpugO/8aaD9/GbTnXgjN2V+IceKZKqopAGBoGpQggLLKLwRKIBQLddMqEQgzEJqmwTDMNGUm1Upess9XrFiB9957DxRFoa2tTdov2UvTYDCAYRgEAgFF9WoAwOv1wuPxKCrwyHGctPqZbeBpPmt9KMXhcOCxxx5Db28vbr/9dixfvlyVdgu1clvMIHuapsHzvGqr4aVowcoF7Tn/D9G/vgS+vwvhV34Nw1V35L3PVJaZdGhX/xvolk6ENnwD/GAvAt+5GcyCZeD2bEeo9whMnb8DXZ39Ykeu11Wn0+Gqq67CpZdeit///vdYv349vvSlL+Giiy4CwzA4fPgw2traipaKudD3rUajQUtLC/r6+lSpN5aOHTt2oK6uDi0tLQCmzlX3b+vTHhOkKLBvvwGA/+cPBYaiAL0e2tXn5m2sBIJaEMsMgYDMcTOZVvJomsbKlSsxODiIvr6+tMcIgoC6ujo4HA5FYwyFQhgdHVXsmhEMBqWg3Gxf4tkcp3Za5rGxMXz729/G7bffjvPOOw+///3vVVNkCkkxFQCDwVAScTOlCsVooL/yawCA6JsvgR/qy1tf4rOhxDITC9PSCdP3n4Zm5TkAFwX38QeApQyCx43Qk/8BQaalOZ/o9Xpce+21eOmllzA5OYn169fjhRdewMDAANrb2/MSx1KqCrZOp0N9fT36+/vz0j7P83j33XdRXV2tOA7JcOVtoGf9szArzUAQBGj0ehjveyxjIU4CoRQg2cwIBEwFyPv9ftn7pxLUeZ7H5s2b0dramtF6MjQ0hLKyMlnZpXieR1dXF1pbWxUXMHM6nejt7cUpp6QvkqYWalsexsfH8cQTT+DgwYO47bbbcMYZZ6jW9kwj17n1eDwIhUKyXBSLZUEqRjazRPwP3g7+o/egWX42jF//Yd77i60BlA2RPz2H8O9/DHDcVPyDIADWKsDrBlVth+7zl0H76YtVyUqVy30RDAbxgx/8AFu3bsWNN96I9evXl0ShzELe66OjowCgqpswy7LYunUr2traJItMJhLfYQLPg9uzHeEDuxHQ6tBx0dVgyitUGyOBkAMkmxmBIAelCkKqRQCaprF69WoMDw9j//79aduora2Fw+GQtTo5MDCA2tratONM1U4kEsmqBkS2qCUUTExM4Hvf+x5uvvlmfOITn8Dzzz9fcEVmJsSEKDnGZDKlDERWo6/jBcMVtwM0A3bbRrB7dxS072zuOd0XLoPxgZ+AqrRB4P95/OQEwPMQxkYQ/s3DCP/2UVXGF3tfKB0rwzBYs2YNXnvtNQwPD2PdunV47bXXwPN8UZ81pck1RLIZs91uh9/vV7R4lo5QKIR3330Xc+fOTanIJBun+Jl4vhRNQ7NkBbxnnwfzZy4migxhRkGUGQLhn8hN0ZwJmqZx+umng2VZbN++PeV+DMOgqqpKWqlLhcvlgkajyWjBSfUSjkQiimo/FAvx5epyufDggw/ihhtuwFlnnYUXX3wRZ56pvKaGIAg5C0jHg0Afl+I3i/iMExGmuQPaT03FGYR/+5hsl61s77fY47K95zTzTobu2rv/lZhKTFTyz3+jf3kRvDP9d41SlI51//79mDNnDkwmE2699Vb84Q9/QG9vL9avX4833nijJBYPlIwh22vV0tKCoaGhnBNy+Hw+bNmyBUuWLElanFMk3TgT771QKESyZBJmHESZIRD+SabK6EpZvHgxqqqqsGXLlpQvraqqKvh8vpRZbiKRCCYmJlBfX6+4f5FwOKzY8iRSSGHe4/Hgv//7v/HlL38Zp59+Ol566SWsWbMmpzif40EZSUYuQp+YBICQHt1F1wEmC/juQ2Df+QuAzPOe7f1G07Qqgjy/b2fsYKZ+/fNfQeDBHdqtuE21FIxgMIjJyUk0Nv6rorzZbMbtt9+O3/3udzhy5AjWr1+Pv/zlL0VXanK1gGaCYRg0NjbmFD8zMTGB999/HytWrEhZcFXpPAqCAJZlZ8TiF4EQC1FmCIR/kq6oZLZCSmdnJ9ra2rB58+aUtWUaGhowNDQ07XNBEDAwMICmpqacCg3mYpnJpjijUjweD370ox/h6quvxrJly/Dyyy/jnHPOOW4VETXIZW70en1RkwAUW1CVC22tgv78awAA4ed/BiEUyNs9mSybYjbQLakDvykAlNEi/S87ZbVK57x3717Mmzcv6baysjLceeed+O1vf4v9+/fj/PPPx5tvvpnzvVLIe01pX2azGRaLRXEiGGAqo+Pu3buxevVqWCyWlPvJvXbi2CORCHQ6nWpeCgRCoSDKDIHwT2iaVjUYVXyRNDY2YvHixdiyZQs8Hs+0/QwGAzQazbRtDocDVqsVer1esUARu7+abma5FCVMxOfzYcOGDbjyyiuxaNEivPLKK/jUpz6VdyVmpgjT+cJsNhdVmZlJSqr2s5eAqmmA4BxF5H9+l7d+aJpWxf1P+8n1oJs6gMTvMYoGZa0Cs+jUf32U5Drk69p4PB6Ew+GMQe/l5eW4++678cwzz2D37t244IIL8Pe//z3rZzbb81HDXVDOvjU1NQgEAnHFbDO10dvbi0OHDmH16tWqxUKK8+T3+1FZWalKmwRCISHKDIEQg5orUrEvpaqqKqxYsQLbt29PGiPT0NCA0dFRaXVWfMFVV1cDQE6rtuJqm5xxZkIN1y2/349HH30UX/rSl3DSSSfh1Vdfxac//elp7eZL6chFMcwXhVSwTCZTSithKZEYoFwMKK0O+iu+CgCI/M/vwI/LS9ihlGzTMydCURQMt38XMJVNuZkxGoCiAZ0Ohtu/B0qT3t00X/fhnj17sHDhQtn7l5eX495778Wvf/1rbN++HRdeeCH+8Y9/lNxCROJ4srlXGxsb4yzzqdrgeR47d+7E6OgoVq9endZ1OJcFJhIvQ5iJEGWGQIghH+Z18YVnsVhw5pln4uDBgzhy5Ii0naIo0DQNm80mKTojIyNoaGiI2yebPoGptJ3pzqtQwmIgEMCPf/xjfPGLX0RHRwdeffVVfO5zn1NUnDRfpBOSCiFAFdIapdFocg48zoVc7mWl+6hx7TSnnwPmpKVAOITw8z/Ly7VSyzIDAEzbHFge/yP0V98B7Se+AN0Xb4H58ZehWXSaonbUsmo4HA5otVpYrVbF16OiogLf/OY38Ytf/AJbt27FRRddhHfeeSerceUDNe4FnU4Hk8mEiYmJlPuIGcuqqqpw2mmnxRVBTkY29z1FUQiHw7JKBRAIpQZRZgiEGEShP13BR6UvitgXnk6nw+rVqxEMBvH+++9LQqUgCKioqEAgEMDw8DDMZnPKlTc5/cf2ybLstLZyEfKUHhsMBvHjH/8Yl156KZqamvDaa6/hvPPOS+vSl03gai6oKaCW2uoxMP38ipkEIB+xGuK+SlfKxYx36cZEURT0V90OCALYTX8Gd+yA7HHJRU1lBgCoMit0n70Uhuu/Cf36K0FX1ShuQy3XroMHD2LRokU5WXWrqqrwrW99Cz/72c/w9ttv46KLLsLmzZuzagsovWfUbrdjYmIi6T3gcDiwefNmLFq0CO3t7XHb1PreEgQBoVAIFotlRrmBEggiRJkhEGKgaRparTZtEbVcfc1pmsbixYvR2tqKTZs2we12S8fX1dXh4MGDaX3L1ci0U4gXVigUws9+9jNccsklqK+vx6uvviq7SJ5armDFEFpKwdKUCaPRWNS4mXyRzX0jR8hmZi2AZvVnAADhZx5V/b5Sy80s3yg9797eXlRVVcFoNKrSv81mwwMPPICf/OQneOutt3DppZdi69atitsppWcRmBpPXV3dtEQwR44cweHDh3HWWWelzFimVv9utzuvfRAI+YQoMwRCAtmkMc5GuKmvr8fKlSuxa9cudHd3A5iqsdLc3IzJyUnF7ZUK4XAYv/zlL3HRRRehoqICr776Ki688EIwDFPwsagttMhxR8uny5NaGI1G1Yr2nSjov3QLoNODO/AR2G0bVW07V2WmUPeWkueJ4zgcPXo0ZQazXKipqcF3v/tdPPbYY3jjjTdw2WWXYdu2bar3kytKXCTFrGQ+nw8sy+L9999HMBjEmWeemTbmUa1x+Hw+oswQZixEmSEQEoh1NRORW3RMKSaTCWeddRZcLhc2b96MYDCIjo4OjI+PF70WiNLzikQiePrpp3HhhRfCZDLh1VdfxaWXXloUJUYuubgMptpWaqu+yTCbzWmTAJSS4lUq0DV10H3hSwCA8O8ehxBNXhsqG3JVZkrxnjt8+DDa29unxeupeW/V1tbiwQcfxMMPP4yXX34Zl19+edpCxcnIRwyXkrZj92loaEBXVxfeffddKQumGmQaB8dx0Gq1JCUzYcZClBkCIQGaphW9gHMVJGiaximnnAKGYdDV1QWfzwe73Y7h4eGMx8qNn8k2IFQO0WgUzz77LC644AJoNBq88soruOyyy2bEi7EUhUA55CoQZhKeZ+q85BNBEKD7f1eAqqiGMDKI6Jt/VK3tXOvMFFP5TBavFAqFMDIyMi3GI3Z/paQ7x7q6OvzgBz/AD3/4Q7zwwgu44oor8NFHH+XcbjJSxWcpJdk89PT04NChQ5gzZw6am5tljzHX53VychI2my2nNgiEYkKUGQIhCWLcTDLyITgEAgE0NzfjjDPOwI4dOzA+Pg6O4+D1etMeJ+clxnFcXoRTlmXx3HPP4fzzz4cgCHjllVdw+eWXZ+WmB8wMa0C+x1jIQoYajQbRaDTndk4UKIoCZTRDf+lNAASEX/4l+ElXTm2KsXkz2TKT7J79+OOPMX/+fFXHJaethoYGPPTQQ/j+97+PZ599FldddRV2796t2hiUjicdicqfaJlft25dXN0ZpW1lA1FmCDMdoswQCEnIRw7/dO2NjY3BbrfDYrHg7LPPhs/nQ3d3N7q7u+OEnHxaWBJJ1RfLsvjDH/6A9evXIxQK4eWXX8aVV16ZtRIjUqrWgNh5yPcYCzkHJG4mOzRnfx506xzA70Pk5V/l1JZoNZ0pCQDSId67ExMTYFkWtbW1RRtLU1MTHn74YXzve9/Db37zG1xzzTXYu3evrGMLHfPW19eHLVu24KSTTsLChQuh1WphMBjiFrKyta7LQRAE0DSdc1wOgVBMiDJDICSBpmkwDFOQ+iNi7IL4MqEoCosXL8aiRYvQ39+P9957T9o3GxeHbAXkxOM4jsNLL72E9evXw+fz4Y9//COuvfbarF+CM8ESA5SukpUrZrO5JDKapboPSilDXSwUw0ylagYQ/dvL4AZ6cm6Tpumin5da7NmzB0uWLCn2MAAALS0tePTRR/Gd73wHP//5z3Hddddh//79aY8pVDbCSCSC9957D+Pj41i7dm2cZcRut2NsbEx2/0qfoVi8Xq9UnJlAmKkQZYZASIFer0+7Xa2X2+joKGpq/lUHQmy3qqoKn/nMZxCJRPDmm2/GCZ758DtPBc/zePnll7F+/Xo4nU689NJLuP766zPOT6YxzGQlIVfBsxQEV6PRWBJJAJQqLWrdN7m0o1m0HJpTzwR4DuHfPa7KWErhnlBCsvH29fWhsrISZrM57vNiPOuxfba2tuLHP/4x7r//fjz55JO4/vrrcejQIdX6UnrtBgcHsWnTJnR0dOCUU06Zlq5eo9HAYDDA5/PJai8XxZ+4mBGOB4gyQyCkQKvVql6fJfHlwrIsWJaFyWRKuj9N01i7di3sdju2bNmCo0eP5tS/kpcez/N47bXXsG7dOoyMjOCFF17ATTfdBIPBkJcxyKFUBL5c6+CUgiInCtD5VhpKlUxW10xKt/7y2wBGA27nZrC7P8jLGEuZZJbbI0eOYMGCBdP2VfO5ldtWsv3a29vx5JNP4t5778Vjjz2Gm266CUeOHMl5THKVUZZlsX37dgwMDGDt2rVpXfGSWWdiycXlOPZYnudz/k4nEIoNUWYIhBRQFDUtDkTtDDbj4+OSiT+dUDlv3jx0dHQgEongnXfekb1il01AuSAI+NOf/oR169ahr68Pf/jDH/CVr3xFtcJ32YxvppOuCGsx0ev1aa0zJyqxhTRT3aN0Yyu0554PAAg/+ziEHGNecrk/SuHe2rt3L2bPnj0tFXvi/OUjC5jSY2fNmoWf/OQnuPPOO7Fhwwbccsst6Orqyuu4+vv7sWnTJjQ2NmLFihVpsz1SFAWNRgOaphGJJE8BLnceYuc7VkEXBAF+vx8VFRWy2iEQShmizBAIachnUKT4MikvLweQ/uVkNBphsVhQW1uLxYsXY/v27Th06FDGdK5KhGhBEPCXv/wF69atw9GjR/H73/8et9122zSXETXJ1cIxkyhGJrRMfZrN5rRJAE4UZTNb9BdeB5jLwPceQXTjn3KaLzWPLfRzMjk5icnJSbS0tEzbVkpWycR5mjNnDn72s5/htttuw4MPPoivfOUr6OnpUbVPj8eDzZs3w+l0Ys2aNWhoaJA9zsrKSrhcuWXMSzX/FEVhcnISdrs9p/YJhFKAKDMEQhq0Wu00f2a1BDyfz5fSvSwZdrsdk5OTMJlMWLNmDQBg06ZNcfVokgk1mcYrCAL+9re/Yf369di/fz9+97vf4Y477pCUrFwhAnH+yJRpLZPgmCkJgBLB80S8zlRZxZRCAyDy/M+BYPYJFfLhipXPDFix7N69G0uXLs1LX0rGkS0nnXQSfvnLX+KWW27B9773PXz1q19Fb29vTm2yLItdu3Zh165dWLx4MZYuXaq49lZZWVnG9PyAMiuNOGc8z0MQhLxY3AmEQkOUGQIhA4nWmWQvjmxeqm63G5WVlbL3pygKDQ0NGBgYAE3TmDt3LlatWoWBgQFs2bIFPp9P0SqoIAj43//9X5x//vnYvXs3nnnmGdx9990oKyvL+pxSjTsTJ6IgrJR8zJFOpwPLsqq0NZOtZunINO/acy8AVdcE3jWOyOu/ld1uISwWahV4TNUuAPT29sJqtea8+JHN+asdf7dgwQL86le/wg033IDvfOc7+NrXvob+/n7Fbff19WHTpk2oqqrCWWedlfXcUBQFo9GYMeugXOU1dr7cbndR02cTCGpClBkCIQM6nS7Ohz4ZmSwgiccKgoBIJKI48NJgMKCsrAwOh0Ma22mnnYYFCxZg586d2LVrV0bhVBAEvP3227jwwguxc+dO/OY3v8E999wDq9Wasf98KR3HqyCsJnItL0rdzWianvE1TvJJpnuT0uqgv+I2UBSFyBu/Bz86JKvdbKyo2ZKv5ysajeLo0aNYuHBhzm0VekEj3ZwsWrQIv/nNb3D11VfjW9/6Fu666y4MDg5mbNPj8eCdd96RXMqSud2lI9kcVFVVYWJiQtbxSq6zz+dTtJhGIJQyRJkhEDJA0zQ0Go2iVa9EEo/1+XxZx6LU1NTA7/cjGAxKn1VUVGDNmjWorq7Gpk2b0N3dnfTYd955BxdffDG2bt2KX/ziF/jGN76hKACUKB2ljxKlR+7KbyEpRmxRrmhOWwNm/jIgEkH4Dz/Nqg2apqUYuJliqdy7dy/mzJkzLej/eGHp0qV45plncNlll+Eb3/gG7rnnnqRKDcuy+Oijj/Dxxx9j6dKlOPnkkxW7lAHJn1Oj0YhwOKzKPSG2Hw6HYbFYjtvrRjjxIMoMgSADvV6vqiDvdrvjlAilL6qWlhYMDg5OW1Fvbm7G2rVrEQwGsXHjRoyPjwMANm/ejIsvvhgbN27Ez372M9x///2oqqrKqv+ZImipQaFiDoqBaAmwWCyqJgGQE6NVTPLlzqW/6naAosBu/hu4w3uyakNUZmbCosHExAT8fj+am5vjPlfLta2YWc8SWbZsGZ599llcdNFF+PrXv45vfOMbcDgc4Hkehw4dwqZNm1BdXY3Vq1erFmsI/GsOMiXqyHR84v8ul4u4mBGOK4gyQyDIQEyTqZYgluhipvTFyzAM6uvrk/pz0zSN+fPnY/ny5Xj11Vdx++2344033sATTzyBf//3f09a7VlJ/2oKCcUWbItFYlKJYmIymaZZZjIlFkhHRresHLeXKkzHSdCs+RwAIPTbxxXf27GWmVJHEAR8/PHHOPnkk5NuA3K/jmrX9FKD0047Dc899xzOO+88XH/99bj66qsxOTmJtWvXJnUpkzOGTO7LAGCxWGQlApDTtiAIYFk2r1kqCYRCUzpvVAKhxNHr9aoIoaFQCHq9Pqc2KIqC2WyGyWSS4mdi2bZtG6677jr09vbijjvuwOc+9zn09PRkrE9TSOUi19orao1VSayTWpSSEpdsJb1UFIpSmic56C+9CdAbwR/aDfa9vys6NldlppBzdfjwYdTV1ZW0QJyvNNl9fX0IBoP4/ve/jxtuuAEPP/ww/uM//kOygsciJw4q0zUXv+vVqgfl8XhIOmbCcYdyp04C4QRFp9MhGAzmHKjr9/sVpWROh91uR19fH7xeL8rKyrBjxw48+uijaG5uxiOPPILa2lps3LgRZ555JsbHx7Fr1y7odDosXLgw6RgKKcQWa+U2VomSo1CVasFLNTEYDAgGg6rdl2oxU+Zd/E6gq+3Q/b8rEHnxKYR//wQ0p54FSidv4SJXZaZQc+X3+zE0NISzzz67IP2JKH0OxWuiVpa04eFhHDhwADabDWvWrJFiYlavXo3Nmzfj5ptvxqJFi/CVr3wlzvqdqyVSPAcxrXKu33terxeNjY1ZtUEglCpEmSEQFJCuYrrcF00gEJC1MiZXaWpqasIbb7yBF198EQ0NDfjRj36E+vr6ae3YbDasXr0ao6Oj2LFjB4xGIxYsWJBSgM1ndqViEnuN5FyvmSJQ54LZbE5Z9+hEUOaSobTgrIjuC5ch+vfXIIwOI/KXF6Ffd4WsNmJjZnIln9ds165dWLJkSdIMjfm0ZBY6dbPI6OgoDh48CIvFgjPOOCNpBsrVq1dj1apVeOedd3DjjTfi5JNPxi233JI2W5jS71cxUUe21jCKohCJRGA0GrNKTkAglDLkjiYQFKDT6VIqM3JfnNFodJqbWbIXm5wX3e7du/HII4+goqICt9xyC1auXDltHDzPx31mt9tht9slpcZsNmPBggVxL2mlCQFORGEXiF81VWLtKTXMZjPcbnfSbTPtXNKh5Npke96UwQT9l25B6MffQeSVX0N79mdBV0yPU0tEzZiZfF2zvr4+GI3GuOQh+e5T6fOk1vM3Pj6OgwcPQqfTYdmyZRmVCIqisGbNGpx11ll4++23cd111+G0007DTTfdlDRjpNKFIovFEpcFM5vFpsnJSdTV1Sk6hkCYCRBlhkBQAE3T0Ol0iEQiWR2fqFiIKFUe9u7di0ceeQTl5eX43ve+h+bmZrjdbgwODqKpqWnamJMhKjUOhwMffPABysrKMH/+fBgMhqIlBEiG0hXyfIwnVbviZ0qtPdkQqzSpbTHTaDSqFM8sdUWuUGPTrP406D8/D77rICIvPQXD9d+M255snko9AUA4HMbhw4exdu3agvSXrZtYrtd4cHAQx44dg9FoxNKlS2GxWBT3f84552Dt2rX4+9//jmuuuQYrV67ETTfdlFOmM7PZDKfTCSC7eCCe5xEOh6WiyATC8QRRZggEhej1ekQikayy9gSDwWkWECXH79+/Hxs2bIDZbMYDDzyA1tZWaVtFRQX8fj8mJiamrZym66e2tha1tbUYHh7Gtm3bYDAYMGfOHEX1Z/JJLoqVWsK1WDQ1H253qcaY+LncKt+p2sw0F1qtFpFIBDqdTu7Qp6HGXKc7v3RKZSm5RFI0Df1VX0PwgZsQ/fvr0J57MZiWzn9tT3IO2Sgz+VAeU83lrl27sGjRorjaJPl2LSsUPM+jt7cXPT09qK6uxvLlyxUXNE6Eoih86lOfwic/+Un87W9/w5VXXonVq1fjxhtvzEqhiC1um2rOE69H7LWcmJhAQ0NDFmdCIJQ+RJkhEBTCMEzWK9mBQECKS1AiCBw8eBAPP/wwdDod7r//fnR0dCTdr6GhAd3d3TAajTAajQD+9RLM5CddX1+P+vp6TExM4ODBg4hGo+js7Cz4C1BNwbRYaaTVcGfKh5CaDjFuJpULUbLzT6Zw5TOxQzohrtTQzD8FmhVrwX7wNsLPPgbT/Y+n3Z+macXfKYWyNA0ODoKm6Wm1SfLZfyGsfCzL4siRIxgaGkJTUxPOPPNM1eNJKIrCpz/9aZx77rn485//jC996UtYu3Ytrr/++qysPnIXP2I/43kegUAAnZ2d044jEI4HiDJDIGSBXq/PSpmJze8v50V95MgRbNiwATRN45577sGsWbPS7k9RFJqbm9Hb24v29nYwDCOtuMt9SVdVVeH0009HIBDA4cOHcfDgQbS0tKCjo6Mg9VFKSTAtZuBxLmTTv8ViwejoaFJlJtU1SWY5Skem+Sz0tc93Omr95beC3fkuuI/eB/vhVmhOOWNa/7GuisW+95P1H41GcfDgQaxZs6agY8nnMxQKhXDw4EG4XC50dHRg7dq1ef9uoygKn//85/HZz34Wb7zxBi677DJ88pOfxHXXXSc7iyDDMCkXphLvo0SrTF1dXdG/lwiEfEGUGQIhC7RarfRiUUI0GoVWq824X1dXFx566CEIgoA777wTc+bMASBPuNZqtairq0N/fz/a2tqg1WoRDocVp901mUxYunQpWJbFsWPH8Pbbb6O2thazZs3K2QWjlEkUMPPZfikhuk+mItO41cgMV+h5kdNfLskd6LpmaD9zMaL/83uEn30MzJLloBgNBJ4HRdMpXYJKiY8++gjz588/LjJguVwuHDlyBKFQCLNnz8bSpUun7ZPv60DTNM477zx8/vOfx+uvv45LL70U5557Lq699lrJmp5qLOIzqtFoUo5TjMsUt3EcB6/Xm9KaTyAcD8z8bycCoUjo9XoEAgFFLz+WZdMKBd3d3diwYQMikQjuvPNOnHTSSXHb5QpSFosF4XAYg4ODGYXUdAiCAI1Gg7lz52Lu3Lno7+8vybiaVGSTPECpgKuUQgns2QhlooIeGxcR296JSKrkDnLvAf3514Ld9BfwA90IP/MouH0fgq5vhvHuH6Tsp1gkjmFkZASCIMSlegfyr5Bn236y43ieR39/P7q7u6XvrWTWx9g2lI5J6bMmCAJomsb69etx3nnn4dVXX8XFF1+Mz372s7jmmmukxaLENmMXpuRYSwHA7XYTqwzhuIcoMwRClohFNJVmmEr2Uunt7cWGDRvg9/tx1113Yf78+TmPr7q6GkNDQ/B6vbBarYqPT/bybm5uRnNzsxRXE4lE0Nraiubm5mmKQClYIPKVla3Y5yWHbFaXTSYTfD5fVvfLiYbsmChLOXQXXY/wr36E6Dt/BfxeCF532mDtUiAajWLv3r1J3cvyff+rsVDg8Xhw9OhRTE5Oor6+HmeccUbS5BZyv6eyHVOy9mP/ZxgGF1xwAdavX4+XX34ZF198Mc477zxceeWV08ar0+kQCAQUjX1ychJtbW1ZjZ1AmCkQZYZAyAGxiKZcISRxv/7+fmzYsAEejwd33nknFixYIPvFmqlPQRCkhAATExNobm5Ou2+6F24iYlxNJBJBd3c3Nm7ciLKyMnR2dkqrnvkWeIqtLOWj/2KfU1lZGSYmJo5LZaZYc0tRFLSfXIfoX18CP9QDUBQE1ziEsRFQ9unFbUuFDz/8EAsXLpTlFpuKQqdKF60wPT090Ol06OzsxCmnnJK2LTWUlNjrlpjlUu73OcMwuPjii3H++efjpZdewvnnn48LLrgAX/rSlySlRqvVKorVdLvdsNvtBYl1JBCKCVFmCIQc0Ol0CIfDKevHpGJwcBAPP/wwnE4n7rjjDixZskRRv3L6E7e3tbVh//79cZnUUu2rFJ1OJ7mgjY+P4+jRo/D7/WhqakJra2vaNL9KsvIk26aWG0q25ENIK7bFx2g0IhwOF3UM+aJYcysIAiiNFvorbkPwB3cCAg8IQORPz0L7/66CpqYuL/WDcrnX+/v7odFoci6wmC9LbWI7Pp8Phw8flopCrly5MqcU49mMIdPnctFoNPjiF7+Iiy66CM8//zwuuOACXHTRRfjiF7847R7J1JfL5VL8biEQZiJEmSEQcoCmaWg0GkSjUQDTV+XEv8XPR0dH8fOf/xxDQ0O44447sGzZsqz6VfLCNJlMqKiowODgYNYKhhxsNhtsNhtYlkV/fz/ee+896PV6dHR0wG63yz4HuUHmxSioF0uxrSj5QkzlnSxuRi3SCe6lZJ3Ildh7hA8GQFXbIThHAQqI/vUlRP72CvT/7wrov/QV0DSt6rlne2+KxTFTuZdlO0a1FRue5zEwMICenh5otVp0dHRktMJkQs26VLlm99NoNLj88stxySWX4LnnnpMsNWvXrk1Z4yy2X4/HA5vNRqwyhBMCSsEX0/HzhiEQVITneXi93rgXTOJzNTw8jMcffxwHDhzAt771LZx66qkFG184HMaOHTtw2mmnoa+vT0rZXAhEv3WxYFtHR0fGTGjHq5IgF4qiFFv6MqFkTkdHR6HX65O6mhXCFerSSy/F888/n9c+ckVxwLd3Er7bLgR8k8m2wnDrd8Cf/kmMjY2hqalJvYFmwdatWzFr1qxpCxCl8FzyPA+Hw4He3l6Ew2HY7Xa0t7cf19kVRSKRCJ5++mm8/PLLuOqqq3DxxRfHJZOJvT40TaOrq2takVMCYYaS8YuHWGYIhByhaVqq5QLEW2ccDgcef/xxdHV14fbbb8f1118flyJTDQEhUxt6vR7RaBQ6nQ4NDQ1SDZpCCCbl5eU45ZRTwPM8BgcHsXPnTnAch/r6ejQ3N5e0EFIs4S1fVd3lkixuJh9uUDMZxfNgMoNumQV+/87p2ygKkb+8CN0Z/1bQ+U12n3V3d8NkMimypBaC0dFR9Pb2wufzwWazYf78+SgvL097zPF2v+p0Olx11VX4xCc+gX/84x9Yv349rrjiClxwwQVgGCbO/dblcqG6upooMoQTBqLMEAgqYDAYEIlEpBfo+Pg4Hn/8cRw+fBi33347Vq5cCQA4duxY3HFquTTIxWQyoaqqCv39/WhpaUm7r1yhWs5+NE1LmdBYlsXg4CB27NgBnudRX18f5/6Wrq1CKhjFXoUuFsniZkp5LnieLzlXmmmZyhgN6DIr+OQ7gx8fTit850MwT3Rr83q96O3txVlnnaWonXw9k263Gz09PXC5XLBarXHJReSO63hEp9Ph+uuvxxVXXIFnnnkG69atw9VXX41169ZJqdWdTmfSGjoEwvEKUWYIBBWgaRo6nQ7Dw8N48sknsWfPHtx+++347ne/m3PbaggLscdXVFQgEolgZGRECvBVms0sm/1ENBoNWltb0draikgkgsHBQWzbtg08z6OxsRHNzc0p43pKWaguZZQWfixE3IxalJoiAyS/T+nmdmA7DfAJKg1Fg2mZpUockdK6SiI8z2Pnzp1YtmyZ4vmMtQhk6x4pjtvn86Gvrw8OhwMmkwltbW2KhPJiZqxTkppfDUXLYDDgxhtvxJVXXonf/OY3WL9+Pa655hosX74czc3NJflcEAj5gtztBIIKuFwu/Nd//Reuv/56nH322XjxxRexevXqaS+tbF60mSwVctvgOE763263Syt42Y5LDXQ6Hdrb27F69WqcfvrpAID33nsPmzdvRnd3d9bFPksNteNfculfzlhMJhP8fr/ifk5kMl0X7SfWAToDkChkCjx0/+9KVYTcbO+zffv2obm5GRaLJeu+ExUJuefidruxb98+bNy4EXv27IHVasWaNWuwYsUK1NbWKhpDpvNXOr/ZptxP9XniNVY6Hp7npy0wGI1G3HzzzfjDH/6Arq4uXHPNNXj33XfBJyrNBMJxDLHMEAg54Ha78eijj+L999/HXXfdhfvuu0/KbAYoL8SoRgHOZCQrhlhfX4/+/n4wDIOKigrZ48wXYl2Izs5OhEIh9Pf34/333wdFUbDb7WhsbEwrbCm1PqQ7Xsk2ueNRi0IonhaLBW63O2NcghwEQQDHceB5XvotCELSH2CqWKPb7Z6WgpumadA0DYZh4v4uFTJau2y1MP37Ewg++V0Igz1Tx1iroL/iNmiWnh43B4VkdHQUXq8XixYtyur4VM9GqvkQg/iHhobg8XhgsVjQ1NSE+fPn592aEPsdK3f/XPuLJdfFrXA4nNRqTVEUzGYzLrzwQtx66614+umnce655+LWW2/FeeedRyzahOMeks2MQMgCj8eDxx57DJs3b8Ydd9yBc889V3Kz8Hg8cfvGvjy7u7vR1tam6OWSq5AOAAcOHEB5eTkaGxuntd3T04OqqqqSLZQYiUQwNDSE4eFhhEIhWK1WNDY2oqamhrhS5JGurq64ZBUiPM8jEokgGo0iGo2CZVmwLItoNBqnqMQqI7EKCE3Tcdsoior77LrrrsNTTz0FAHECviAI4HleUorE/xPfYaKSo9FopN96vR46nS5lAchCuicJggB+oBtgI6CbO0Fp/jWmxDnP97ii0SjeeecdrF69Gnq9Pm/9RCIRDAwMYHh4GCzLorq6Gg0NDYpiYAhTiqfBYIhbZBAVNL/fD7/fjzlz5gCYioH68Y9/jI0bN+K2227D5z73OaLUEGYqGW9coswQCAqIfUHcfvvt+OxnPzvtBREMBhGJRKa5E1AUhf7+ftjtduj1etUtAeno7+9HMBiUXnSJffX09MBms6GsrEy1PvPF+Pg4hoaGMDExAa1Wi4aGBtTX1xc1M5raliA12s8FsdZITU0NOI6TFBVgSnjS6XTQaDTQarXSb61WG5dVKdtx55qamed5ScESlSxR+RKVIABgGAY6nQ56vR56vR4Gg6Fglp5USQu6u7vR3t5ekDEAUy6d7e3tORfHTIbH48Hg4CAcDgc0Gg3sdjuamppSFu6NJdv7vRTSR+eTgYEB2Gy2ad91PM/j2LFjWLJkyTTLTezC29e+9jV8+tOfPq7niHBcQlIzEwhq4PP58OSTT+Lvf/87vvrVr+Kb3/xmyheC0WiUlJlEVxmDwYBQKAS9Xp/2haL2y8ZsNmNsbCxlX62trejp6QFFUTn5zWeDUgFELM4JAKFQSEr5zLIsKisr0dDQIG3P5zhiUTsWKpZ8CWiCICAcDiMYDCIcDiMcDoNlWUlZ0Wq1YFkWNpsNOp0uKytYMYQmMRlHMnec2LTpHMdJ5+31ejE+Pi7FlYnWHJPJBKPRGFfPI1cEQYiby1yub6Zj020/evQozGazbEUmU19iUhGHwwGfzweDwYCmpibMnj1b8fxl+2wc70I6y7JJ72un04n6+vqk28rLy/Htb39bcol+7LHHcOedd+JTn/rUcT9fhBMHoswQCGkIBAL4yU9+gjfffBNf+cpX8PWvf12WUGcwGBAIBKZ9rtfrEQwGVXHpUhJbU1ZWljagm6ZptLW1SQqN2WzOeXxyUfpCjT1vg8EgxdnwPI+xsTH09fXh448/hl6vR01NDex2u6yYoFJ9sasxLkEQEAqFEAgEEAgEpMQKBoMBBoMBZWVlqKmpibNMhEIhOJ3Okq4FpJTYuWQYBiaTCSaTaZpQHI1GEQwGEQgE4HQ6JSXHaDTCZDLBbDandFlTMobE/5XGzGS6N1Jtn5iYwODgoKI0zInxJizLwuFwwOFwwOv1gmEY1NTUYPbs2UmfNzmKV7oxpxqT0n6y3Vdtsumb47hp7x+O4+D1ejFr1qy0x1ZUVOA73/kOXC4XHn74YTzyyCO4++67cc4555Tsdx+BIBeizBAISQgGg/jZz36GP//5z7jpppvw1ltvKVqZ1uv1CIfDca45giDAYDBgcjJZFXDlKBF8tFptXDYz8fjYlxhN02hpaUFvby/q6+uTCnmlQKrzpmkatbW1UgakUCiE0dFRHDlyBH6/H1qtFjabDbW1tSWR8ADIX2E/juPg8/ng9/sRCoUATCkuRqNRcnPMhGhFTEWy7FWldq/IJXHcotucGJsgxu6ICuHw8DCi0Sg0Gg2MRiMsFguMRqOsbFqFtMgmg2VZfPjhhzjjjDMU9ScuFjgcDkxMTICmadhsNrS0tMiyhGareClFyT2Zr/mW8yyo1ffw8LCiIsiVlZX43ve+B6fTiQ0bNuCRRx7B17/+daxZs0aV8RAIxYAoMwRCDKFQCE899RRef/113HDDDYqVmFgMBgN8Pl9ccTqdTlfUdMPJXN9i0Wg0koWmoaEBRqOx0ENUDYPBgJaWFqk4aKxyEwgEoNFoVFNucvHxV6N9lmXh9Xrh8/kQiUQkq0NFRcU0IVupEhyNRpNaIdJZGI43xEQFoiVHhGVZ+P1+TE5OYnh4WNqnrKwMJpOpJOdo586dmDdvXsbYFZ7nMT4+Lv0IgoDKykrU1dVh4cKFqibfyJciXKz5zke/kUgk7jkUBAHBYFC6Lkqprq7Ggw8+iLGxMTz00EN46KGHcM899+DMM89Uc9gEQkEgygyBgKmA51/96ld4+eWX8eUvfxlvvfVWzsHAot9+NBqVJUwqWaUXX/7iMXKEAZ1Oh0AgkNGFjGEYtLa2oru7Gy0tLaplOcrGjURp++naTqXcHDt2DD6fT1JuKisrYbPZFAlr+XZrSZbi1e/3w+v1IhgMgmEYmM1mWVYXJf2bzWZ4vd68ZJ0qhCUn331oNBpYrVbJbVS8Lh6PBw6HAzRNw2w2o6ysLGOcHIC81wbp7u6GTqeTshqK8TuCIMDn88HpdGJ8fBw+nw8URaG8vBy1tbWYM2eOqnFDicwEt7BCkuw8fT6fFM8oZs4cGhrKOqW2SE1NDX7wgx9gdHQUP/zhD/HQQw/h3nvvxRlnnJFTuwRCISHZzAgnNJFIBL/5zW/w4osv4uqrr8YXv/hFVV/asamaxRfUwMAAqqurp1k98v2i3r9/P8rLy9HU1CRr/2g0ip6enowKTT7HnYvwr9R9KxKJwOFwwOl0YnJyEoIgwGg0wmazobq6GuXl5VmvRqvhTsZxHNxuN7xeL3ieT2kBUPN6RKNRDA8PSwpgIcg1m1kpIcYzeL1ehEIhmEwmWK1WmM3mpNfo2LFj6OzszMtYJiYmsGfPHpx11llSwVzxh+M4GAwG1NTUoLq6umBumDNJOZHjspbPOkGi+68Y5D84OIiKiopp6fZzZWRkBD/4wQ/Q09ODb3zjG1ixYoWq7RMIWUBSMxMIyYhGo3jmmWfw3HPP4corr8Tll1+et5VHMWOUiMfjQTAYVFzdWg7pXriDg4PweDyYN2+e7Pai0Sh6e3vR0tKSNFPOTCFboWlychJut1tarQamCkqKCk6+M7+JBSTFlfKysjJUVFTE1WXJN/kUsJNxPCkziQQCAXg8HimGq7y8PE5JTlXbJxdEd7G33noLbW1tkttgRUUFqqurUV1drfjZTvY8qa2Y5Fs5mGnEPoderxcul0t1d79YhoaG8N///d8YHBzEN7/5TZx66ql56YdAkAFJzUwgxMKyLJ599lk8++yz+NKXvoS//e1vWWclkktsMgAx9bHT6ZR1rFIBIdb1LBGr1YqBgQHZbQFTMRPNzc3o6+tDU1OTapmtCr0im21fogtRa2srgCnB0O12w+l0Yv/+/ZKSWllZiYqKClRUVMBisUjXIRtYloXL5YLX6wVN01L/xSoQqtfrEQqFFF/7TALviSisxsbcRCIRuN1udHd3Q6vVorKyMuf5CIVCcLlccLvdmJycRDgcBjCVhnnRokWYP3++Kgp4snt7plhYZiKxcWscx8HhcGDevHl5/U5oaGjA448/joGBAXz/+9/HD37wA9x33304+eST89YngZAtRJkhnBCwLIvnnnsOTz/9NC699FK8+eabBbU0GI1G+P3+uBoTqQrnxaJmULnZbE6aLjrZ8bH96vV6tLa2ore3Fw0NDWkDh+UqKblmfSoWNE2jqqoqLoaEZVlMTEzA7Xbj0KFD0hzrdDqUlZXBarWisrIyrRApCAImJyfhcrlAURSsViva2tqKpsDEUlZWBo/HM02ZySZTVC5piGci6eZIp9PBbrfDbrcjHA7D5XKhv78fBoMBlZWVaZ8zUakW7xmfzwdBEKDRaCSlurW1FSaTCfv370dNTQ3mz58ve2yx24v1LGa6P0rRvTVfffl8PsmddHBwEPX19QVLn9/U1IQnn3wSfX19+P73v4+JiQncd999WLJkSUH6JxDkQJQZwnENx3F4/vnn8etf/xoXXngh/vrXv6oW0K4EMdVrNBoFMLVC6/P5pNSvhSDWaqNUCNVqtWhvb0dPTw/sdjvKyspkH5uKdCv3uQgSagoicqwHYnVzu90e93koFJLc1IaGhhAKhaT03OXl5bBarTAYDFLRyrKyMjQ3N+c10DodqVItWywWuFyuafvPVIVUDdRS2kX0ej3q6urg9/tRWVkJl8uF4eFhWCwW0DSNQCAgxd5EIhHpulRWVqKtrU1yPUzE4XDA5XJh1apV08YuN3VwqV5DpeNScj+qdc5qpWj2+Xyw2+1wuVygaRo1NTWqjE8JLS0t+OlPf4qenh48+OCD8Hq9uP/++7Fw4cKCj4VASIQoM4QZB8uyePjhh3HHHXekdBHjOA4vvfQSfvGLX2DdunX485//XPTifyaTCR6PB4IgoLy8HE6nM+/KTOLL1Gw2w+PxxBXtlPuSZxhGUmh4ns+58Ge+XFXUFL5ERSabmipiQcrE2Ci/34/e3l7JTc1gMECn00Gj0UhB/RaLBWazWRJmC0GqNMIMw4DjuKxcHvOJUuFUTUuQmufGsiw8Hg+8Xi927dqFsbExqb5PIBAAx3GoqKhAS0sLZs2alfJ7LHE+/H4/9u3bNy3VrpyxFyImplTJx2JIrosz4XAYNE1jbGwMc+fOLWr8YltbG5566il0dXXhwQcfRDAYxP333z/N8hfLli1bEAwG8clPfrKAIyWcSBBlhjCjcDqduPbaa3HZZZclVWR4nsfLL7+Mn//85/j85z+PN954o2RqpVAUJcUfGI1GyZ9dDVK9MBM/q6yshNvtjlNElLxoaZpGe3s7+vr6wHFcXlL2liLJBH2lQko0GoXT6YTX64XNZsPcuXPj0n+LQq3P54PL5cLAwIBURwL4V/X5srIymM1mlJeXF0yoMZvN8Pv9eU94oASlVsBiwfM8AoGAVMBUrAcUDochCIKUVrusrAw2mw2LFy+e5mIWCoUwPj6OoaEhKT4rXQ0bjuOwbds2LFu2TPqezNUyUWqKTL6Ua7XPM9f2JicnUV5ejv7+fjQ1NRXMvSwTHR0d+OUvf4mjR4/iv/7rv8CyLO6//36cdNJJ0/Y9+eSTcdNNN2Hv3r24/fbbS+5eIsx8SDYzwoxh7969uO2227Bhw4ZpQYg8z+O1117DT37yE3zmM5/BzTffnLEoXLHweDzgeR4jIyMwmUyqWGfkrjxPTEygu7sby5Ytk912qlXagYEB6PX6ae5V+WamBY6Hw2E4HA5wHAebzZbSRS8ToquRz+eD1+uF3+8Hy7LSdp1OB71eD6PRGPdjMplydl0Ta6fU19fn1I4cZko2M0EQEI1G4xQV8XcoFJISflAUBYPBAJPJBKPRCIvFIqXUTmyvp6cH7e3tKfvkOA7j4+Pwer2wWq2orq6WLHexz+n777+PpqYm2WnYCaVLd3c3TCYTBEFAa2trySzOJXLo0CE8+OCDoCgK999/P2bPnh23XRAE/OhHP8Lhw4fxxBNPFN1TgjCjINnMCMcHr776Kn75y1/i+eefjxOeBUHA//zP/+CJJ57Apz71Kbz++usls3KVCrPZDJ/Ph+rqagwODqqizMgR7gVBQEVFhZRiWC6pVtGam5sxNDSE4eHhggi5IjNFkQkGgxgbG4MgCKipqVGsXCcqkWImrFQpvUOhEAKBAILBIEKhEMbGxqR4HI7jpP00Gg0MBgOMRiP0er0Uz6XX66VCr4kWH5PJhJGREUXjn2nwPI9IJIJQKIRwOIxIJIJIJIJwOIxQKASWZRGJROJc7sS5jL02ZrMZJpNJsXugHEsDwzCora2F3W6XFiZMJhPsdrtk5Tt48CDMZjNRZIqEmostsffc7NmzS1aRAYC5c+fimWeewYEDB/Dd734XWq0W999/v5ROmqIo3HPPPfjLX/6CdevW4de//jUaGhqKPGrC8QJRZgglDc/z+M///E+MjIzg1VdflYQsQRDw5z//GY8//jjWrl2LV155JesV70LDMEzcSnls2s1cSfcijU0AkE5wUhK02tDQAIfDgYGBgWnCU6n42BfakhMMBjEyMiIJnjqdLqt5UHqMGKOTiUgkIik9oqDu8/kk4T0ajUoCO/Cv6+hwODAyMgKDwSApQBqNBjRNS/ez+D/DMNLn4v/ifU/TtCToJ7s2if/zPJ/0f5ZlwbIseJ6X/uY4Tvod+3fs9thtsVAUBZ1OB61WC51OJ8UymUwm6PX6uNimfKAkLouiKFRXV6Oqqgoejwc9PT0wm83geR5OpzMu4D+f5OsZz6bdUvm+SfVdo+Q7V/x/fHwcfr8fixYtKvlFOpF58+bh2Wefxb59+/Dtb38bZrMZ9913n2Rx/OxnP4vOzk5cccUVePDBB0lRToIqEDczQsni8/lw3XXX4eyzz8ZNN90EYOpL/s0338Sjjz6KM888E7fddltBM4KphSAI8Hq9cLvdCAQCqKurK1jfO3bswKxZs1St8j0+Po5AIIDm5mZVBAq1BZNCCDqRSESyXtTV1c3oIqPJGBsbA8uyMBqNktLD8zx4npeUA0EQwHGcpGCI22I/j7VsJLsu//mf/4lvfetb01KXJ1o6RAUpVlGK/Vv8X1SmxM80Gk1GpaQYgjHLshgaGkJLS4vsY2IXJwYGBrBp0yacc845qK+vLwnBnjBFupjGdDLYpk2bsGzZMlRWVs4YZSaRjz/+GA8++CCsVivuu+8+qWbX5OQkrr32Wpx33nm46qqrijxKQomT8cuMKDOEkqSrqws33HADHnjgAZx55pkQBAH/+7//i0ceeQSnn346vva1r+WcTavYRKNR+P1+HDlyZJp/MZA/gaqvrw+hUAhz5sxRtV2XywWXy1US9VHE77Vs6/QoOY5lWTgcDkSjUdTW1pa0K0gq5Jwzy7IYGBhAa2trXgXlmRIzozbRaBTDw8OylJnE6xWJRPDuu+9i+fLliEajmJiYmFYPSS6FsmQW06pTKlacdBw9ehThcBiLFi0qaFbDfLFr1y48+OCDsNlsuO+++9DU1ASO4/Dtb38bwWAQP/rRj4qWlp5Q8mR8WGf200E4LvnHP/6Bm266Cb/+9a+xevVq/N///R8+97nPYfPmzXjuuefwwAMPzHhFBvhX7RmxKGEiSl+2cvevrq7G+Pi4orblUFlZiZqaGnR3dyMSiaTcLxv3EaXkUqtG7nGCIGB0dBS9vb1SkctERabU43vk1hIRCzLGxt4crxT6mqVK/52O2P14nscHH3yAhQsXoqysDFVVVejs7EQ0GkVXV1faQrnJzjWX8y+F1N1q1v8pFi6XC6Ojo5gzZw4MBsOMV2QAYOnSpXjxxRfx5S9/GV/72tfw1a9+FQ6HQ3I1u+CCC+B0Oos9TMIMhajBhJJBEAQ88cQT+OCDD/Daa69h27ZtuOWWW7BkyRL87ne/Oy7TABuNRthsNvT09OTsLidXCDGbzXFpodVcpSwrK4NWq0VfX1/KKtVKhaVsx6bkvJTOgd/vx8jICKxWqxTgmgyxzVJcCVZyHcSxG41GBAIBRS4vpXju6Sj0WGPvEfF/Jdfmo48+QmNjY1xiCIqiUFtbK1l7KIpCfX39tJVvtc+11JX3mUAwGMTAwACam5thMpmOO3fVZcuW4Y9//CO2bduGW2+9FS0tLbj33nsxZ84cXHjhhfjxj39MCnESFEOUGUJJEA6Hceutt6KzsxM33HADLrnkEixYsABPP/00bDZb3L6CIODo0aOoq6ubMUH/qaBpGuXl5TCZTHC73arGsaRDp9MhFArBYDCoLtAYDAapFo3Vas1aCc01CDgfigzHcRgaGpLSpMp1i8i2UGE+yaYvq9UKj8cjS5mRW2meMIUgCKBpWkrpnGqf2G1Hjx4FRVHo6OhIur9Wq0VLSwt8Ph96e3tRUVGB6upq2eM5nq5dsc9Hrivn4OAgdDodGhoaSra8gFK6u7unvQuWL1+OV155Be+99x5uvvlmdHZ24sc//jHuvfdeXH/99Vi3bl3xBkyYcRBlhlB0hoeHce211+ITn/gE3n33XTidTvzqV7+C3W6HIAjo6+vD9u3bsWPHDuzbtw88z6OzsxN33XXXjFdmgCnForm5GQcPHoTVas1LFp/Efex2OxwOhxSMqTYMw6CtrQ0DAwMIh8NZpW5Odk6ZzjV2m9wVbrnzPTk5ibGxMdTV1aUtHplqjErGriZqCnFKUjQfT4JwJkRFJBfLhBzlL3bb8PAwhoeHsXr16oxtWywWmM1mjI6Ooru7G42NjRlX/I+361eo80n1vZNOQRWV2L6+PlRUVCAYDGb1LihV9uzZgxdffBETExOwWq049dRTceqpp+KUU07BypUr8dprr2HLli247777cNJJJ+H111/Hxx9/jG9961vHhYsdIf+QBACEorJ9+3bccsstsFqtWLx4Ma655hr09vZix44d2L17NyKRCJqbm3Haaafh1FNPxYIFC47LIEGe53Hs2DHQNC2tnCp1N1EitPp8Puzduxenn356VuNVwtjYmJTprJAvpnTzp2SueJ7HwMAAGIZBfX19VueQS0ICpeQ7gLu3txeNjY15ew4vueQSvPDCC0VfSU+H0rHJ2T8QCGByclKW4u9yubB7926sWrVKcVr3YDCIoaEhVFZWHpeuuzOV/v5+WCwWTExMoLOzs2BW+kLjdruxc+dO7NixAx9++CF8Ph9sNpv0jvd6vXjsscfAsixMJhN++9vfpl08IpwQkGxmhNLlm9/8Jp566il0dnaitrYWHMehtrZW+lJbvHjxCVUlOBwOY/fu3Zg9ezYoipJWeuU+o0qF2Lfffhtr167NdriK8Hq9GB0dRUtLi2o1dTKhhjDs8/kwMjKC2tpaWCyWkhWuC8nExAQEQZDlrpTNNcgmm1mie2GmWkqliN/vh8fjyajMBAIBvPfeezjjjDOyzpwnCAIcDgfC4TCampqkgpvHG7kq9vm4h5K1OT4+jkgkgoqKCrjdbsyfP1/VPkud0dFR7NixAzt27MCuXbsQCoVA0zT279+PcDiMV199FcuXLy/2MAnFgygzhNJEEATMnz8fF110ET71qU/h5JNPJqsvmFqdCwaDsNvtADCt1oaafPDBB5g3b17axANyXKPkfIcIgoBIJIL+/v6UiQFKDYfDgVAoVHLCXqGLgCb2HY1GMTAwgLa2trz0oWZq5th5KnXFxufzwe/3xwXyJxKNRrF582acfPLJOa3ci8+13+/H8PDwcRWfoRQlz1Ouz16y4ycnJ+F2u9HS0oKuri4sXLgQer0+6z6OBwRBwODgILZv346nn34aJpMJf/jDH4o9LELxyPjlffz56xBmBBRF4cCBA8UeRsnR1NSEjz76CFVVVVK19GSosWJYV1eHkZGRtMqMnFicTNvFOAC9Xi8lBqioqEBlZaWi8RZqpZ3jOPT398NsNuctpigX1HCdk9tPYntiimae5/N+PdRoX40kEIVanU8X+C9uf//99zF//nxJkcl2bOIxZrMZbW1t6OvrQ3l5+bRkKzMRpTGE6b7DMrmqivsoGVssXq8X4+Pj6OjowOjoKOrr6094RQaYmtOmpiY0NTVh/fr1xR4OYQZAIqsIhBKCoijMmjULAwMDGffLlbq6OjgcjrT75LqynXiMmBhAXBHOpa18EAqF0NXVBZvNhpqampJfzY9Fjesjd5vZbIbX61XcXyKZBMlCkSphQ77GkSzQP5MVdseOHWhubp6WgjlXGIZBe3s7WJZFX19fzla/fFgNldTDUbPOTGIfalr6/H4/xsbG0N7ejkgkgmAwiIaGhpzaJBBOVIgyQyCUGOXl5aioqIDL5Yr7XG2hSq/Xg2XZtIUQY/tUS0gRV920Wi26u7vBsmza/QvlUuXxeDA4OIi2tjYpS97xXDcjG5cZcX+r1YrJyUlVxlCqpFNw1CCxLZ7nU7oz7t69GxaLJS+ufaJiVVdXB6vViu7u7mnfCdnUJFKTZG3mM/uf3H2yyTwJTCVhGBkZQWtrK2iaxtDQEObNm6d8sIQTnmeeeQY33XQTenp6ij2UokKUGQKhBGltbYXH44kTKnKp1p3qpWu32xVbSNTCZrOhrq4OPT098Pl8KffLVmBQwsTEBFwuF9rb26HVarMW8mcS2YxZvBYGgwGRSETtIZU8+VS+OI5Lapk5fPgwOI4rSFC41WpFXV0duru7petbrEQKxYwLS0e28yG6EYbDYWnRhGEYuFwu2Gw24l42g+np6QFFUTj77LPjPt+4cWPSz9WE53n8/Oc/xwsvvJC3PmYCRJkhEEoQiqIwe/ZsDA4Opn15ZusuIdLU1ITBwcGsx5krRqMRHR0dcDqdsuuXZEKpoDE6Ogq/34+Wlpasky0UKrajlNo2GAwIBAJ5aftEJJmbWV9fHyYmJnDKKacoaisXRcBkMqG5uRl9fX0IBAJFs57l+t2mdB+5ZDsfNE1LSVBaW1vBMAw4joPH40FTU5Nq4yOcWHzhC18AwzB47bXXij2UokKUGQKhRDGZTKisrITH45ECrjORbp9k26xWKwKBgOJ6NmpC0zRaW1uh0WjQ1dWV1u1M7b6HhobAcRyampqKXh08130yBSqrRayrmcfjmbZNiQUx23M6HhGLJ4oMDQ2hu7s7q5S0ud7LOp0ObW1tGB4eLqjCmqloaKpjct1HjWc/U2KOaDSK3t5eNDc3SzWaBgcHMWvWrJJ2tyRkz/Lly3HgwAH89re/zVsfNpsNq1atwgcffKDaguBMhCgzBEIJ09TUBJ/Pl1LAT3yBpouDSPXCLC8vx/j4eMa2M7WTK9XV1aivr49zO0t2fmoxNDQEhmFQV1c3I4SJQghkSsZhNpunuQemEkaztSzOhOuiFrFuZmNjYzh8+DBWrVolfZbtXGTjMklRFDQaDdra2jA0NFQwhUZJXa1Ycr1PeJ7P6fh0Y6AoCizLSoqM6E42NjYGu90+I9LUE7LDZDLhpJNOQktLi+xjzj77bFAUpSgGZt26dRAEAa+//noWozw+IMoMgVDCUBSFzs5OKetY4gtTjcDY1tZW9PX15dxOrlAUBaPRiPb2dkxMTMDhcKQdQy6r9mLbtbW1Ba3bUsh0w2qQKduYTqebkbEz4nkV6rrLuWaiZcblcmHPnj1YuXKltIKfrZAf23c28XVi9sHh4WEEg8GMxxbLkpZNv3Izk+X6vHEch56eHjQ0NMBgMEAQBPj9fgBTGSUJxy+FiJkBppQZACe0qxlRZgiEEsdgMKCpqQkjIyNZCcOZXvQ2mw1ut1t2e8lqjyg9Jh0Mw6ClpQUMw6TNdpatEjI2NgaWZeMqrRfSqqHGKnA+SDaXmealvLxclaxmhUY8r0Jd99i5TXXP8jwPv9+PDz/8ECtXrpRW8NUKwM+2DY1Gg9bWVgwODiIUCuWlj0KjZE5zSQbCsix6enpQW1srWWBYloXb7UZHR4eidgmEVLS3t2Px4sX4xz/+oUrK/JkIUWYIhBlARUUFrFYrJiYmUhYzTIUc64bNZpOd1Swb169slA452c6UCk8ulwvBYBCNjY0p98n36nKuAl++xpfNuMrLy9NmoiNMJ9U8e71e7Ny5EytWrIDRaMy4fyHRaDRoaWnBwMBA2lTuxULuM6FW7SA537eRSESyyFgsFgiCAJ7nMTg4iM7OzpRpuAmEbFi3bh0ikQj+8pe/FHsoRYEoMwTCDKGhoQEcxyEQCExb3ZeTTjQZ4nGtra3o7+9XZ6AykCtMxLqdDQ8P5xTkHgwG4XK50NzcrMrY5JCr4lEKgmwqYgPW1RRw81nLpVTaSiQYDGL37t1Yvnw5LBaL4uML4d6l0+lQX1+ftrBmNlYMNcYud0FFrecpUzuhUEiKkREVU0EQMDY2hpaWljhllUBQgxPd1UxT7AEQCAT5dHR04MCBA6itrYVWq43blksK54qKCvh8PnAcp8qKYSYXMCUCjOh25nK50NXVhYaGhmnCQKbz4zhOqu1A07RU8yFXUs25WsJlpjksprIjXmPR1ayqqkq1dpWSai7UnJ98zXU4HMbWrVtx0kknwWq1ZtVGMkttPsZrMplQUVGBwcHBpOmE85GJTC3y3Zf4PPj9fgwNDaGjo0P6LqUoCm63GwaDQbXnhDCz+e///m8cPHhw2ufiZ3fffXfShY2HHnoINptt2ucnn3wyWltb8de//hXRaHSafHC8Q5QZAmEGwTAMZs2ahcOHD6OpqQkMwyR1nUgnzKTaVl9fj4GBAbS2tuY8znysFFdWVsJisWBwcBAGg0EK3pdDX18fGhoaoNFoCrJCWwghrRSsNhRFoaKiAv39/XFCWqEVrVKYi2wIh8PYsmULli5dqkrskTjv+ZoPiqJQWVmJQCAAl8uFyspKVdsuZgKBbOYsdsyCIGBychJOpxOdnZ1xWegmJycRCoUwd+5cVcdNmLm8+eab2LRpU8rtL7/8ctLPv/Od7yRVZgBI9aFcLhfsdrsq45wpEDczAmGGYTAY0NbWhoGBgbj6M7Ev42QCTaag5/b2dvT29soaQ7Eyamm1WrS1tUGn06Grq0tWhqXR0VFYLBaYTKZ8DjNn1BDkCpmVTYRhGPA8H+dqVgrKRTplvhSIRCLYsmULFi9ejOrq6mIPJymp5qqhoQFOpxPRaDTvfeWbbC3aicrXxMQE3G432tvb4+oFeb1eeDwezJkzpySeC0JpsHHjRsnNMvZnzZo1AIDu7u6k29va2pK253Q68d5772H58uUnnCIDEGWGQJiRlJeXo6mpKU75SBQGMv2fiMFgAEVRUtpQtdzEcj02mQBQVVWF5uZmjIyMwOFwpGwzFArB6/WipqZGlTHmU+AqZsaqXPuxWq0FyWqmRnHXQrgbJSM2PkRUZBYtWiStsqoVO5JrO3JSFlMUhaamJgwMDOTUVymQ7n5Il3lQ3CYIAkZHR+H3+6UsjCKhUAjj4+OYN29enIJDIKjNn/70J3AcJ8XOnGiQp4tAmKFUVVWhsbFRkUCRqTp7Z2cnjh07BiD7pAKZhCk5wqScfXQ6Hdrb26HRaNDV1TUtbawgCBgaGsoY8K+k/1JdWVVbyVLantVqhcfjUXUMycjH/Bdq7kRraSQSwdatW7FgwQJJyY5NppDr+HItrin3eIPBAIvFgtHR0az6S+y3FJFTf2ZoaAgcx6G5uVmKxwOAaDSKoaEhLFiwgGQuI+QdMfCfKDMEAmHGUVNTg+rq6riil+kUlkxB0vX19XA6nTnVjlErsF4u1dXVaG5uxtDQUJyVZmxsDOXl5dDpdLLbUiveoNACmtpCvtL2xFikUknbq2T+C6GgiuMRg/3nzZsX5wqSLvFGsaxtcqipqYHX601ZCypf/RaL2PuK53n09fVJWd5iYVkWfX19mD9//gkXiE0oPIFAAG+99Rbmzp2Lk046qdjDKQpEmSEQZjgNDQ1ShiEguauJXIGBoijY7faU1p5CZOnKBp1OJ2UP6u7uRiAQgNfrTRkomW5cpeLuUyjUEiZLqYBmLvEy+bhuFEUhFAphy5YtWLBgAWpra+O2cxyX0Q2pVO+nuro6DA0NFXsYqiDHqkxRFMLhMLq7u1FZWRlnXRMEAdFoFH19fZgzZw4MBkMhhk04wXnrrbcQDAZPWKsMQJQZAuG4oKWlBQaDASMjIwDSC9OZhNdZs2ZJrmZKj5VLvlZjbTYbmpqa8PHHH0tzkKvbTbaUsoUntl21+pDraqaWwpgNark4KiUYDGLLli1YsmRJ0vgtlmWh0aRPLlpoC4bca2Q2myEIgqxkHKko1jOazTjcbjcGBgbQ3NyM8vLyuGOj0Sh6enowe/ZslJWVqTo2AiEVJ7qLGUCUGQLhuKGzsxMajSbOQgMoTwSg1+thNBrhcrnyM9ACYLfbYbVacezYsaxjOZQIWPkSzvOZYjeRXM9Bo9GA5/m0QdNi3zPJtShbxPkMBALYunUrTjnllJRZy+RYZgqNkmtUX18vLaQUCqW1otSwlo6MjGBychLt7e3Q6XRx7rvhcBg9PT2YP38+UWQIAICzzz4bgiBg48aNso8Rs5ylylqWCMdxeOONN1BfX48VK1ZkN9DjgNL69iQQCDkxa9YsGI1G9Pb2SkJlNi/xuXPn4tChQzNS6BwdHUVdXR2qqqrQ3t4Oj8eDnp6elGlk1cwiVmquQJnGIydzlVwoiiopV7N8Xws5Lkk+nw/vvfceli1bhsrKypTHyLHMlDI6nQ40TU9LwiGXbK5VOuVP7Ux2HMehu7sbGo0GLS0t0/oOBALo6+vDvHnzYDabs+qDQMiGd999F06nE+edd96MfF+rBVFmjgPuv/9+3H777SUnSBGKQ0dHB6qqqtDT0yOtXipVaCoqKhCJRBAIBDLuqzRdbj6/cDmOQyQSgclkAkVRYBgGjY2NqK2tRX9/f9I0zkpcrtTI1JaJbNrIVnhT81oIgoCKioqSUWaKlYJZxO1244MPPsDy5ctRUVEx7ZjYv9MlACgmSp7t2tranDObqUWya5PJYpjq+GAwiO7ubtjt9qQxeH6/H8PDw5g/f37Siu0EQj4hLmZTEGUmz/T09ICiKJx99tl562NgYACPP/44tm3blrc+CDOLxsZGNDQ0oKurS7JIKBXu5syZgwMHDmTcr9CuHumYmJiQBMdYjEYjOjo6oNVqcezYMXi93pTjS0e+x59tgHqi61axFjZKLatZvsg0v+Pj4/jwww+xcuXKlC5HsW1wHFeSlhklz7bBYADHcTllNssn2biNulwuDA8Po7W1NanFxefzweFwEIsMoWg8+uijEAQBn/70p4s9lKJClJnjAFEjFzV0AoGmadjtdjQ3N6O7uxvhcFjaJncVv66uDpOTk4pdR4oh7IufezweVFZWpjxedD2bnJxEb29vVhXM87niL0dZkpOpKxfrTq7nZ7VaSybeSq3irnKyA4r7jIyMYO/evVi9ejVMJpOs4rP5djNLpQCrTVVVFZxOp+rt5orScxUEAYODgwgEAmhvb0+aXnliYgKjo6OYO3cujEajWkMlEAhZQJSZ44Bzzz0XRqORKDOEOGiaRk1NDTo6OtDX1ye5jClJWztnzhwcPHhQUb/5FvZTfR4IBGAwGDL2zzAMmpqaYLfbU7qenYioFfdTUVFRkAKachDPKRthNlaxlJsFra+vD4cPH8bq1auh0+kyJjsQt7Esq0o9EnG8iRnj8pHwIRnl5eXw+/05tZEP66eS9kKhELq6umAymdDY2Dht7gRBwMDAAAKBAObOnUssMgRUVFTggQcewNVXX13soZywEGWmBKEoSnYmCwAwmUz41Kc+hYMHD+Lw4cP5GxhhxkHTNCorKzF79myMjIxgfHw8bnsmYauxsREulwuRSCTfQ5VFurF6PB5YrVbZbYmuZxqNJq3rWb7JVXArNUWMpmloNBpF90wmYTvbukmpjpc7nlQxLsk4evQoBgYGsGrVKsnKIrdfnueloHKlY43dX2wj14xx2d5TFEUpuvaprnuhA5lFBcrhcGB4eBjNzc1JLbzRaBTd3d0wm83o6OggigwBwJQy853vfIcoM0WEKDPHCaKr2auvvlrcgRBKDpqmYbVaMWvWLESj0bhMZ4IgZAyM7ezsVGydyRfphKxAIKBYuBAEAdXV1VLWM7HgZr7Ih7tPPgW/bAXriooKRa5mmeYl2ep4oUmXOGL37t2YnJzEypUrwTBMTuNTej3lxEopre2TiyWnvLwcbrdb1r7ZzFOu55GsnVAohO7ubjAMI6VdTiQYDKKvrw91dXWoqamByWRSNnACgZA3iDJznPCFL3wBDMMQVzNCUiiKgtlsRmNjIyoqKnDs2DFp9TST8NTS0gKn05lTUbxkqCmQsiwLhmFkC4KJ7kNi1rOGhgaMjY2ht7c3Ls5ILeSMr5QsLXLHmzifFosFPp8vbh8lqDkH+ZhP0XrA8zw++OADaLVaLFu2TJZbWzGurxq1feS6f5WXl8dde7VRGsifSgkV2xkbG8Pg4CAaGxuTZisDphIBjIyMoLW1FeXl5SRrGYFQYhBl5jjBZrNh1apV+OCDDwpevIwwM2AYBmazGRUVFWhpaUF/f7/s2Ib58+dj7969cZ/lKpSpaVHw+XyyrDKZYiD0ej1aW1tRW1uLoaEh9PX1ZZUkIBeK4R6UC8kEZZqmodfrJQU4F2sDkNt5JetbDcE+Go1i8+bNqK2txfz587MeT6yLWSJqJTBQa18581bqxT/F/yORCLq6uiAIAjo6OmAwGJIePzw8DJ/Ph9bWVuj1eqLIEAglSGl96xByYt26dRAEAa+//nqxh0IoURiGQVlZGYxGI9rb26UVx8T4hEThpra2FsFgMC6uRI3VZ7WE71AoJCujkFwh1mAwoL29HdXV1ejv78fw8HDKdMMzzZKSTZvZtFtZWSnb1SzZHKpZ0FNOf0oIBALYvHkz5syZg7a2tpzai0ajKTOZ5aKIKbFSKrVoZkKj0aiyCJCvZ8vpdKK/vx+NjY2w2+3T+qIoSlJ2tFotmpqaoNVqiSJDIJQopZfY/gQiXbDY+Ph40u02mw0PPfRQ0mPWrVuHO++8E6+99hpuvPFGlUZJON6gaRomkwk+nw9tbW0YGxtDd3c3mpubpYxKyYSbRYsW4eOPP8aqVasApBeC1Ba4MhEKhVBTU6NKW7GIgb4ejwc9PT2wWCyoqamJW31WIgjSNF2QyvRKXXHy4RZlNptlW4mTWWIKFQSutC+n04mPPvoIp556atJimEqJRCKKMpnJrUWUyzOY6ni5bRqNRvj9/qQ1n5SQqT+l1y4ajWJwcFBK/pHqWKfTCZfLhcbGRhgMBtA0DbPZXPDEBAQCQR5EmSkizzzzTMptfr8/6fbW1taUykxdXR10Oh36+/tVGyPh+ESj0cBiscDv98Nms8FsNqO3txdVVVWoqqpKekxlZSV0Oh1GRkZQV1dXtBd7MgGG5/mMFdRzEZDLy8tRXl6OiYkJdHV1obKyElVVVYpXvwthxcnGpSubscmZT7PZDK/Xm7JwZLoxKeknF8Rzl9NHX18furu7sXr16pRuSWIsjdwx56PGTK7KbK7zbTAY8ppIQ0TJ8zc2Ngav14uGhgYYjcak9zvHcRgcHIRGo0FHRwdompbcc4kiQyCULsTNrIiI7jyJP8CU0pJsW09PT8r2/va3vyESieDzn/98gc6AMJPRaDRSnInRaERnZyfC4TB6enqmVfEW78vFixdj3759GTOg5ZNshQo1hJGqqip0dnaC4zgcPXoULpcro4tUNn3nW/FJl5lL7nFyzqmysjLnIorp4mfUmqNkGcES296/fz8GBgZw5plnplRkxO9ppdaCdJYZNc5RTq0bNdFqtSndMrMlW1c4j8eDY8eOgWEYdHZ2Stcusa6S1+tFV1cXqqur0dDQICkyFouFKDIEQolDlJnjCDGTmZimmUDIhEajQXl5ubQ6X19fD7vdju7u7rj0quLLXK/Xo6WlJWM9o3QCWK6CvpK+8gFFUbDb7ejs7EQ0GsWxY8cwPj6edYxHKmUon3Ei+VIIE89Fr9dDEATFgm26ayq39ksutVJif3Mch23btoHjOJxxxhlpA9yzmddMBTPVuA8K+YyItWYSF0Tkki69dLo+E/8WF2a8Xq8U/5a4r8jQ0BCcTmdc7RjRek0gEEofoswcJ3AchzfeeAP19fVYsWJFsYdDmEHQNA2LxSIJaSaTCbNmzYLf70dPT880QXTWrFkYHByMS9WsREFRu2aImA2q0EoNTdOSUkNRFI4dOwaHwzFtvjIJo5lqeuTD+pCqr3z0UVFRgYmJiZzbyWUs2bYXDAbx7rvvoq6uDosWLcp5TMmIRCJJ65pkS7ETUgiCAI1Gk1KBzeZ5kNOnCM/zGBoawtDQEOrq6tDY2JjSBTUYDKKrqwtmsxltbW1SenedTkcKYhIIMwiizBwnvPvuu3A6nTjvvPOISZygGNGdQlQKKIqS6i50dXVJKZzFbUuWLMGHH34oHZ+rJSIXOI5TVGMmV5LFF1RXV2PWrFnQ6/Xo6enB8PCwtDKdzfnKEcSzdRVL11c+sFqtslOA54tUrmPp9h0fH8fWrVuxZMkSNDc3521s6VIzZ0OpWDpTtZPJRTVT/+nuezGmTVROUrkDchyHgYEBjI2NoaWlBVarVdqm0+lIQUwCYYZBlJnjBOJiRsgV0UIjVjAXBAEWiwWzZs2SsnmJ6VZtNhtMJhP6+voU96O28Fxo5T2dsFVRUYHOzk5YLBb09fVhYGBAKk6qJsnSJedDoVRjbhNrzmQin5aFxDiJVPt0dXVh3759WLVqFSorK1WxJqZTSktpAUotxSrbTIfZxJcFAgEcO3YM0WgUnZ2dkutsIoIgwOVyoaurC1ardVoGR6PRKCvFO4FAKC1INrPjhNdffx3l5eU455xzij0UwgxGVGgCgQBYlpUEraamJoRCIQwMDMBkMsFut2PRokXYuHEjamtrodfrM7YdK7SpKcAxDCMrJkPtoPp051BWVoaysjL4fD4MDw9LcTapVoqz6TsX5M69kqxc6aiurobT6URTU5Oi4/KVCCHVOfE8j48++ggAcOaZZ6YU7LO5j5Odh5wsfIVGjfnOZ4KQ2PkOh8NwOBwQBAEtLS0pY48oikIoFMLg4KDkRpsYG2UymRSlyCYQCKUDUWZKEKUvk127dqGnpweXXHKJqr7XhBOTWIUm1qpgMBjQ0dEBl8uFY8eOSQrNhx9+iJUrV6ZsTxT41IhhSDVetTMnyUHOOVgsFlgsFoRCIUnoqq6uVpyqGFBPAZTTTrJrlgsmkwkDAwOykxAkS2Ud+7/4dzZzkuqYQCCADz74AB0dHWhtbZXVVrZprUUSa8yUmpUmW8SaSrmSam5FJYbjONTV1aW1pnAch9HRUYRCITQ2NkpJKWLHajabiSJDIMxgiDJzHEBczAj5wGQygaZphEKhOKGisrISVqsVIyMjCIfDAKbqb7S0tMQdn41AnEp4UUPIK2ZgtMFgQGtrKyKRCJxOJ0ZGRmC1WlFdXV3wlXk585iPTGpWqxVutxuVlZUZ+5abFCGbejTJ9hkeHsb+/fuxbNkyxYUec7mvwuFw3AJUqvMuZQUn2bWIRCJJa+ck21dO2yKhUAijo6MQBEGyCKdry+PxwOFwwGazob6+XvpcjA1kGAYmk6nkrGMEAkEZRJk5Dnjttdeg0+nw2c9+tthDIRxnGAwGMAyDYDAY53JE0zQaGhoQDofBsiy2bt2K8vLyOEEw16xEseQjA1I+SSWA6nQ61NfXQxAEuN1u9Pb2QqPRSDFIqdopBYE20xgyWSiqq6vR19cXp8yoeV6Jlj+5wf779+/H5OQk1qxZk1IAl2PJyiajnpxMZvm67motHCTbNxQKJXWpzPZcQqEQRkZGQFEUamtrYTAY0l5jv98Ph8MhWZMTlRXxepnNZlWTLxAIhOJAlJnjgF27dhV7CITjGK1WC5qm4ff74xQaQRCg1+sxe/ZsCIKAl19+GV/4whdQU1OjmuuP3H01Gk3G4oOFJJMCQlEUKisrUVFRgXA4jPHxcQwPD6OiogKVlZWSgKWmq1cylAjhmawGmdpgGAYMwyAcDksxVvk6t2QZrxL7CoVC2L59O+x2O84444yUbcmJj8nW1SwSiWTlcqgGsRne1HYBjUQiilIbp7oPg8EgRkZGQNM06uvr41zEksVziUoPwzBxwf2xUBQludIWe4GAQCCoA1FmCARCRhiGQXl5OSYnJ5MKbXPmzAFFUTh06BA8Hg8qKytRVVUlW1jIdSXYYDAgGAyqosyoZS2QExNCURQMBgOamprA8zwmJibQ3d0Ng8EAm802zb9f7THnEnsiHq+E6upqjI+Po7GxUXFfuZAorA8PD2Pfvn1YsmQJbDZbxmNzVbZTobTGjNy2lYwhHwJ9KBSSilTKHUPsfR4MBuFwOCQLcGyCkcTAfQCIRqMYGRkBz/NSDE2yJAQUNVXQk9SQIRCOL4gyk2cqKirwwAMPoK2trdhDIRByxmq1wufzJa3uPXv2bIyNjUGn04HneRw7dgzV1dUZYyTUUB6MRiMCgQDKy8tlH5Oq30Ks1ibrg6Zp2Gw2VFdXIxAIYGRkBCzLorq6GlarNaOLl9rjyQdms1kSOjPFxsReH7WymvE8jz179iAQCOCss86SpfwqzeimZF8xm5naqbKLbXFgWVZy2VOigE1OTsLlckGr1UqWmGT7ie2Jwf2BQAB1dXWSkpKsT3HhQE7mRQKBMLOgFLwgiltWmEAglAyxmc5iBQeWZfHOO+/gtNNOg9lsxtjYGHw+H2w2m1SYLplbixLf/WSf8zyPnp4edHZ2FjXQH1A3nTDHcRgfH4fP54Ner0dlZWXSVWU1V+wTg7QzHSOnzdg5cTqdEAQhpUXk0ksvxfPPP5+2Pbn9xu7j8/mwfft2tLa2oqOjQ9XrlO34urq60NHRkbcxFAMx01hiQpBU8x2NRjE+Pg6/34+ysjLYbLaMAfkcx8HpdMLr9cZ9twCpFRmj0UiyfRIIM5OMLzdimSEQCIoRMwAFg8E4wYFhGKxYsQLvv/8+zjrrLNTW1sJms2F0dBROpxM1NTVJYwRSCSDJSGXVoGkaLMtmnZkoUdhSmnkp8Tg1YBgGtbW1qK2tRTAYhMvlwvDwMMxmMyorK6UgazVX7BOtIdkkX0g1l8BUNrzu7m5JmUnsIxsrRSYrW3d3N3p6enDKKadI1rvENM+Z2kp1bnLGl4xwOFwyMV6Aegqxx+NJaiFNnDOfz4fx8XEpXXlstrFU8DwPh8MBv9+PqqqqpIpg4tgYhiGB/gTCcQ5RZggEQlbo9XowDBOXGICiKJhMJsyfPx/btm3DGWecAYZhUF9fD5ZlMTo6CofDgerqalRUVGSdqSvZMRaLRYrXyYZEYUttV51cM5PFVif3+XwYGxtDJBKBxWJBZWVlTqvOchUKJZadVNA0DaPRCJ/Pp1oQdmIb4jjD4TB27twJs9mMNWvWJBVolV53tZTVVBm/ciEXl021FGK/34/m5uak23ieh9PphMfjgclkQkNDQ8r7NvZcotEoxsbGEAqFUFVVlVTxSVQyxfgYo9FIFBkC4TiHKDMEAiFrNBoNysrK4Pf7pcKVFEWhrq4OHo8Hu3fvxtKlS6V9GxoaJBeRY8eOSbVW0lVaTyY8JhNerVYrhoaGChKjk2psmTJexf7OBbEYpyAI8Hg8GB4eBsdxUnrsZCmG05GLVQyYHt+SCZvNhpGREVgsFtl9KGVoaAgHDhzAokWLYLfbZR2TSqmT6+6ohFAolDQddy59lEKsjFi/JZZQKISxsTFEo1FUVFRIbn7pEJXR0dFRsCyLmpoa1NfXZ7QEipnR9Hq96soigUAoTYgyQyAQcoKmaZSVlcXF0VAUhblz52Lnzp04dOgQ5s6dK+3PMAzsdjtqamrgcrnQ3d0Nk8mEmpqaaUK43ExbFEVBq9WC5/mMKZrVEviKHZsDTJ2L1WqF1WoFz/Nwu93o6+uL+5xhmLzHh8hRcmLR6XTgOE66VmrWm4lGo9i1axcEQcDZZ5+tyO1QjlIXm4lObpvJ5j4cDsdl/Eq2X7LxlMJ9lwqn04mqqioAU5naXC4XfD4fdDodbDabZFnMRDAYxOjoKADAbrfDaDSmja2LvX/EQphKFXoCgTBzIU87gUBQBVGACIVCUlrUZcuWYcuWLTCZTNNcTyiKQlVVFaqqquDxeNDX1wetVgu73Z40FascbDYbnE4n6urqABS+enqugfJySdYWTdPSfLIsKxXlBKYsOVarNW0mp3zMVbr2qqurpWsVu19sSl2lYxKtMfPmzUNDQ0NW7SSu8icmQkjl0paKVMpHNBqNE7jlpuCW02excLlcqKyshNPphEajgdVqhd1ulx2L4/V6MT4+Do1Gg7q6urj7VVRagOnxUqJll8THEAgnJkSZIRAIqqHT6cAwDAKBgOR2dvrpp+Pdd9+FTqdDbW1t0uPKy8tRXl4upSQWBAFVVVWKUi0DQFlZGRwOh+LVc7WgKCplKl81x5KpLY1GA5vNBpvNJrmijY6OIhKJwGAwwGq1wmw2x7WTzroibk+MSciF8vJyjI2NgeO4OOtJrCAq170rEongww8/BMMwSVMuKxlrqnNU6nqXqu1c3Q3VSE6glHTKk6g4Dw0NIRQKoa6uDjU1NbIVCpZlpYx9ZWVlaGlpSWpViY05i/1M7MdgMBC3MgLhBIUoMwQCQVUYholzO2MYBmeccQY2b94MmqZRU1OT8liTyYSWlhawLIuJiQmMjo6irKwMVVVVaV3HYoWt8vJyuFwuyd1FKckEt3wUK8wniUKz6HIGTLnwTE5OwuFwSDFP5eXlKd1yYgVIpbEj6ZQ7YKoOl8vlyli4MrHN2L4HBwdx+PBhLFiwIKWyLO6brMp84j75vH5i25FIJKnCpcQ6o3RbLiTOCcdxcLvd8Hg80v0lJv6Q694lJrEApqx0tbW1GRW1xLFQFAWapolbGYFwgkOefgKBkBdMJhN0Oh38fj/0ej1Wr16NzZs3Y8mSJdOqgycK31qtVkpJ7PF4MDg4CJ7nYbPZklprYgUcm82Grq4uVFZWphW+M6XzzfRZIVFScwdIP97YrGgsy2JychIDAwPgOA4WiwXl5eXTYhsSXa1S9R87t6LikG4sVVVVUnHV2D7kKJR+vx+7du2C0WjEWWedlVGYFcclJ0lDvgkGg9OsCPlSstRS0EKhEDweD/x+P4CpArotLS1gGAYejwdmsznjNRCzmU1OTkrZzFK5PqYbt3h/ifExxK2MQDixIcoMgUDIGxqNBhaLBYFAADqdTrLQnHzyyaiqqpq2ypqs3ofoghaNRjExMQGHw4Hy8vKU1hoxdmRsbCxpFqtUbj7FsqrITXCQbL9cXY4YhkF1dTWqq6shCAJ8Ph8mJiYQCoWkFe+ysjJJuUml1CSOJ1nfqeJPysrKMDk5iYqKirTnRdM0eJ6HIAg4cOAARkdHsWTJEskCJzdtdLZuYZnORQnBYDBpvaVU7SmxCiYen+09zbIsvF4vPB4PWJaFXq+XilomKqpjY2Noa2tL2Zbf78fExISUzayzszPj2DK5PZJsZQQCQYRSYJYu3RQqBAKh5AmFQtLPli1bsHDhwmluQencmWLxeDxwOp2gKAoVFRWwWq3Tjjl27Bja2tqkeIxScQGTQymMled5+Hw++Hw+qTiqyWSCxWJJuxoeK+THfpYuE1VXVxdmzZoFALj44ovx0ksvTQt2FwQB4+Pj2L17N1paWjBnzpyk7RV73uSMo7u7G62trQW1KGRSbkVl1uPxIBQKSQsRZWVl0Ov1KY+dmJhAJBKRkm6IhMNhKZuZyWRCZWWl7GxmsWNKVBqJWxmBcMKR8UudfBsQCISCYDAYoNVqpSDtd955B9FoFE1NTdI+cgXRWGuNy+VCV1cXtFotKioqUFZWBoqiYLfbMTQ0JGVRS+cepZR8BVontp/LGJUcnyo7mjjP4j5+vx8+nw+jo6MQBAEmkwlmsxlmszlOaUw8j1SKjLjCbzKZ4PP5pExUsfvTNI1AIIDdu3cDAFavXi2tyOdihVBiEVNKMstKqsB1JW0qHUu6c+R5HqFQSFJYAcBsNqOysnJa/ZtU14/jOExMTEiWFpZl4XK54PF4oNVqUVlZOU3JyUSqGC2KmiqCSdzKCARCIkSZIRAIBUNMDsAwDM4++2xs2bIFLMuitbU1K8FdTOVst9sRCoUwOTmJ0dFRGAwGqXimx+NRnBVNDoUKFk+1LZNgq2RscvalKEoq1glMnX8oFILX64XT6QTP81IMg8FgiFNwUiUCEOewpqYG/f39aG9vl1IzUxQFlmUll7KFCxfCZrOBYZiMFrzEzFfZxkGppbDGtpMs+F+ui5xSYtsMhULw+/3w+/2IRqMAIF2n6urqlPV40rkUDg4Ooq6uDm63G5OTkwCmYmna29unKRyJcXHJziddLJPBYEibWpxAIJy4EGWGQCAUHNFNZPXq1di2bRt8Ph8WLlwobU8m/GYS+MTUrLW1tQgGg3C73QgGg+jv78fixYvjqs3nqoQU251JLSE7VqiU6+IXe6yYTECcj2g0ikAggGAwiImJCSntsnhtzGazJMjHWm10Oh00Gg0ikYjUf29vLw4dOoT29nacc84508ab+H8y5SXduWRKBJEv/H7/NMuH2v1Ho1H4/X4EAgGp7pPBYJCK0yqJNUkVMzQwMACHwwGO41BWVoampqa0rl9ijFQqS53Yrvhb3Fen08FoNBJrDIFASAmJmSEQCEWD53nJhcjj8WD58uWyK7anWu1PxOFwoKenB1VVVVK2LrPZLKuPfAi6arWZb1e3XBHPk+d5BINB6ScSiQCAtNJuMpmg1+sRjUYxNjaGW2+9FXfccQfKy8uxYMEC6PX6tAkFEhWyYigoycaVisHBQVRVVaWNH5E7fo7jEA6HEQqFpN+CIECj0cBoNMJsNsNoNGY1F4lzznEcJicn4fF4EAwG4fV6sXjx4oyKkdJMfCI0TUOv1xNrDIFAIDEzBAKhdKFpGhaLBaeddhoOHDiAd955BytWrJi2cp0MuYJrXV0deJ6X/O09Hg+Gh4eh0+mkmJBMwexqolab+VZkEuc1U6rcVJm0aJqG2WyGxWKJS40cCoUQCATg8XgQCATg9Xqxc+dOTE5Oora2FtXV1YhGo5JVQcxmlmh1iW1T/CxTPZlM5xM7/tj25ZBpv3A4nFEBiG2D53mEw+G4H9FNjGEYSeAvLy9HbW1tVhaMZOcnCAIikQjcbjd8Ph9omkZZWRkaGxvR29uLJUuWTFM0lGRiS+VyCEwV3xWvOYFAIGSCWGYIBEJJIAhTBRA/+OADLFiwAHV1dTmtsCce29vbi+rqasndLBKJYHJyEj6fDzzPo7y8HFarFTqdTpXzKXWSKR6pAr3VDJSPDfwXBAHhcBj79u2D3+/H3LlzcfXVV+OVV14By7IIBoNxwjvP89DpdNDr9dBoNNBqtdBoNNJPsto2hUz2kEopiFW8uru70dHRAWDK2hGNRsGyLFiWRTQalT4Tz5mipuouia56er0+q5gbueMVXTQDgQC0Wu00hb+/v196VpSSbC4T3QNNJlPaArkEAuGEg1hmCATCzICiKDQ1NaGqqgobN27E+Pg4FixYkFN7sTQ3N6OrqwstLS3Q6XTQ6XSoqalBTU0NOI6D1+vFyMgIotEojEajVNVcbUFY/F+O9SBX0gniyYRuOfslI1mmrlTnLY5JVGLcbjdOOukkNDQ0SBmrBEFAeXm5VIsl9jwikQii0ajkViUqAizLSskDxDHQNB2n7Gg0GjAMA5qmJUuO+JPqs8TzEPvgeV6qe5P4d+xnonLCcRx8Pp8UKA9MWVYYhpHGJsYOabVaaLVa2XOfzvqR7h4T45zEYpjRaBR6vR4VFRWoq6ub1q7T6YRGo1GsyCTGyiRzEdTpdLIssgQCgZAIscwQCISSZOfOnRgcHMRpp50WF2SeC5FIBL29vejo6EibvUl0f4qtryIWj1TT9UyOsCknLmgmEYlEsH//fkxMTEhKDPAvpemiiy7CD3/4Q7S3t09zIZPzvordj+f5OMsHy7LgOC5uu6h4AP9KNyxuE38nWrAYhpmmBMUqQ6IiBSDOgjQ+Pi7VbsknqRRKAJJS5fV6EQ6HodVqpTGls4i43W54PB60tLRIn2WytGR6ZsW5NBqNsmPlCATCCQexzBAIhJnJsmXL0NzcjK1bt6KtrS1thXG56HQ6NDY2oqenJ66gZiwURUm1UyiKkoQ/t9uNkZERqWifqNxkIlOsSaZjM5FNXEc2yFGs0o0hGAzi0KFDcLlcmD17NpYuXRp3TKzlhqIoBAIBGAwGMAwjKR2Z+kmcr1RB5PlKnpDpGoRCobhCsbles1THx14rQZiqD+T1eiXl3Gw2w2azTavXk6o9r9cLt9uN1tbWaf2n+z/WvS6ZSyNJt0wgENSAWGYIBEJJw/M8tm/fDqfTiWXLlknVyHMRAv1+P0ZGRpLWw0iHuIovFhoUK6WbTCZYLJaclZtsUaPNfGVZ8/v92L9/P/x+P+bMmYOGhoa47YkC7yWXXIJnn30Ww8PDUv2hTMpaobKXKU0EkKiAxcbLKD1eLizLSsVNw+EwAEjKdzZuk36/Hw6HA21tbaoE5McmhSAB/gQCQQbEMkMgEGY2NE1jxYoVGB0dxXvvvYeGhgbMnTtXcgNSgiiMms1m1NbWShYaOUKVeCzDMLBarVLcAMuy8Pl8mJiYQCgUAkVR0Ov1knUn0XVHDaE72Up3rihpI5NQLwgC3G43Dh48CI7jMGfOHNjt9rh9Et2gYtvT6XSgaRp+v19Ko50uxkju2LNRiBKtRnJJHKvP55OdEjzZ8akIBoNSTZloNCoVLq2srMzJLVIQBASDQQwPD6dV+uUqeOKzI8arEQgEgloQywyBQJgxcByHffv2obe3FwsXLkRlZWXKdLByvtu8Xi9GR0dTupzJIVn2LFHADAaDYFkWNE1LdT9MJlNRV6SztXDIEVoFQUB/fz+6urpgNBoxd+5cVFRUKBrbF7/4RTz//PNgWRa9vb3o7OyUPZZk1wJQt0hqtlag4eFhKalEtrAsi0AgIP2IrlqpFOdc8Hg8cDqdaGlpUVT7KdlzR9O0lG6ZQCAQFEIsMwQC4fiBYRgsXrwYnZ2deO+990BRFObPnz/NvSuZL38yAbSsrAwMw6C7u1vKcqaUZIqUyWSKE1o5jpNcf0ZHRyEIgpRu12g0wmg0pq2enkiq9MNy0yhn2pYqsDsVkUgER48exfDwMGpra7Fy5UpZNUjSjU2j0cBiscDlcsUprZmydyX+LzeeKDHbWirLl5xzSCbQ+/1+1NXVpT02dizhcBiBQEAqiCkIAhiGgcFgQFlZGWpra3NW0mIVtFgmJibg8XgkNz+5JLtnxPucuJQRCIR8QZQZAoEw4zCbzfjkJz+JkZER7Ny5ExUVFZgzZ07KlWkxqDxZALvJZEJzczN6e3vR1NSUMu4lWQyEXEGPYRipXodIJBJBMBhEIBCAy+UCy7KS8CcqOKmEwGRCu5rItdiPjY3h6NGjCIfDaG9vx9q1a5OON9lcyVGWampqcOzYMVitVqldpecqZ//E7F+5WqcS4TgOGo0m6bEcxyEYDEo/LMsCmHK1MxqNqKyshMFgyOjWl2rcShNQjI6OIhgMplRkUl1L8fqIbWo0GpKljEAgFATiZkYgEGY83d3d2LNnD2pqajB79uyUVo50gp3o1mSz2WTX0VA78FxckQ8GgwiFQgiFQpKgaDAYpIKRYtHIQo5NJBwOo7u7G0NDQ7Barejs7ITValWtr0svvRTPP/+89L/L5UIkEonLAiYHua6GyfZTc+4EQYDT6UQkEoHZbEYoFEIkEkEkEgEAKTueGGeVTCGXo5AkUzCUxBIJgoCBgQHo9XrFcy0ixsUYDAZFlkYCgUBIQ8YvMqLMEAiE4wKe59HV1YW9e/dKSo1Op1NUp0QU6DQaTdKigdmQyS1KzpjEOJxwOIxIJIJQKASO46Tz0uv1cYpOJnc5uRYGsX2O49Df34+BgQFEo1G0tbWhubl52qq7krlORaIyAwBHjx5FW1ubIgE5X+mXUyEIAqLRqOQWFg6HEY1GpXuqra1NsrbJuUbZEHvOct36BEFAJBJBX18f7HZ7nPUwVTvJ3PAoioLRaFQ1bodAIBBAlBkCgXAi0tPTg3379kGv12POnDnTBLREEgVfp9OJyclJNDc3xwlnagWUqwnHcYhEIpIAHQ6HwbKsZNGJLdooVpYXf4D0wfSjo6Po7e1FIBCA3W5HW1tb3qu0J1Nm/H6/FIyeTcKHXC0toqIiWlSi0WhcMU5RmNdqtZJCKVrSeJ5Hf3+/KnWS1CJ2PrxeLxwOB5qbmxXXfBHjeJLV8iEQCASVIAkACATCiYdYZHNkZAR79uxBIBBAe3s7mpqapsV0JIuFqa6uhslkQm9vL+rq6mCxWKR9xX1ij88nmQRxMVNaslgfUQgXfyKRiJTCV1R4xLa1Wi0YhoHL5cLw8DDC4TBsNhva29tRXV0NhmFytnRkG3NiNpvhdDrh9/slZSrRCpGuj2SWBY7jJGWEZVnp/9jfse1qtVrodDpotVqYTCbp71SB7eL4XC4XysrKZM9HLoqXkjTJgiBgeHgY0WgUHR0dGZ+LZG0YjUaixBAIhKJDLDMEAuG4JxgMYs+ePejv74fVakVraytqamqk7akEN47jMDg4CJqm0dDQICsjkxL3JqUucNkIuZmOC4fDGBoaQl9fH/x+P6qqqlBXVwej0Qie5yXBPrGuj2j5YRgGGo0GNE1L50JRlPQ/TdNxf8f+Tnbel19+OZ599tlpfYkxTe3t7RCEqeKliT+xn4vKiPh5rFVNHINGo4FGo5HOQfwt/qihqPb09CR1ySsmoVAIAwMDqK6uRmVlpfR5qvswNsMbRVEwGAzQarUlZaEkEAjHLcQyQyAQCEajEcuXL8eyZcswODiIw4cPY/fu3aipqUFzczOqqqqmHSMGM7e0tGBychJdXV2or6/PWPhQifUiVWrc2O1yXdtSKS3JVv7Hx8cxPDyMiYkJKT5o2bJlkgUqse9UiEqDaOWJVSg4jgOAuG3iMbH/JxKJROB0OpOOn6IoHDt2TEpLLCpKojKV7ifdHInbks2XkvlIRFQC0ykyaiQbUNLG2NgYvF4vWltbp8W3pEpjLSqupFYMgUAoRYhlhkAgnHDwPI9gMIi+vj4MDQ3B4/HAZDKhvr4e9fX1SYOYWZbF4OAgtFot6urqJAG1EEHmuQi8PM9jbGwM4+PjGBsbA0VRsFqtqKurg91uV7X+hxpB95dccgleeOGFlNuPHj2aVXxHMvKdJGB8fBw0TSdVlvNN4rkFg0EMDQ2hvLwcNTU1shNTxGbSIxAIhCJALDMEAoGQCE3TMJvNmDt3Ltra2hCNRuF2u9Hf34+enh6wLAur1YqamhrU1dVBp9NBo9GgtbUVbrcbXV1dsNls06rbiwJi4u/E7cmOSUasa48cBEGQKrc7nU74fD7QNI2KigrU1tZi7ty5eU2Zq9QqJWf/xPlpbm7GwMAAOjs7s1JGYtuT49onjlUJ4rgmJyfR3t6u6Fi1EMfO87wUG9PS0iIp6uI5pZpDjUZDUiwTCIQZAfmWIhAIJyyxwfN6vR4VFRWSG9TExARGR0fxwQcfgOd50DQNq9WKqqoq2O12+Hw+OJ1ONDQ0SMH3sQJi7G8ROW5gcrYJgoBAIAC32w2Px4PJyUmEQiEAgMViQVVVlZTFTe24hmQJE+T0kUyxS9VmYn+x6PV6WCwWOJ1OVFdXKx1+nCIjJ3VxNgiCAJ/PB6PRqKrlSylutxsOhwP19fUoLy+f5kYWq3CLBWXFjGxEiSEQCDMF8m1FIBAIgJRelmVZhEIhVFVVScKymBVsYmICbrcbAwMDCIVCiEaj2LlzJyiKwty5c2GxWGAwGGAwGKSaG0qEQjH+RCyYKdaVCQQC8Pl8UqFFQRBgNBpRXl6OiooKtLS0pI3lEWMeMlkiYoXaZG0kUzoyWZUy7SfuK2c/Ebvdjq6uLlgslqzdzdTIGJZOIRofH0dDQ0NW7ecyPmAqlfXIyAhMJhNmz54tKVSJ1yM2G5zRaIROpyuq8kUgEAjZQJQZAoFAiEGj0cBisYDjOElhoSgKOp0OdXV1qKuri9uf4zj09fVhZGQEwWAQZWVlUpX3aDQqFbeMJVZgjV0ZZxhGqgEj1irR6/UoKytDZ2cnTCaTbCtILNm6dMV+ptT6kouykAmKotDc3Iz+/n50dHSoYn2S6wKYTkET51kslplNnEku5xIMBjEyMgKtVovW1taUirQ4TjGonygxBAJhJkOUGQKBQEgCwzAwm82ScBoKheIUj9j92tvb0d7eDpfLBafTCZvNhpqamqwzkOWKmm0qifFRI3V0uoxasZ/pdDpUV1djaGgIjY2NivtNRKkLYDJERSwbF7hc7oVIJIKRkf/f3r30Rlm2cQC/ptPOMC09l7YcfAEx0ZUJLlwa3ehGhbjTT+BXcKWJiVt3Jm6MH4FIRMOCuDAxujFuFRABoUUOPdFO25npuyDPk+l5hhbKTX+/hEjn9NxFQp5/r/u67olYWVmJI0eO5NWqzUJssVjUDwM8N/xLBrCFrCpTKpWiXq/H4uJi/pP3taOTBwcHo7+/P6ampuLy5csxMDAQw8PDG/7U+0kFme3s9LqPc4PfTl9QdgbNZq9r/ryBgYGYnZ2NmZmZ6Ovra2tdW61nJxPO6vV6PHz4cF0Fr5XrNmtlO1u1Wo2JiYloNBoxPj6eHyja/BmZzs7O/OBP58MAzxNhBqBFxWIxuru782rN4uJi1Gq1daNsh4aGYnBwMB48eBBXrlyJnp6eGBsbW3XeSDvnmezWCOHdClCb9XU0B7ysR6edyk4r1r736NGjcfXq1bxHaad2+uc8OTkZo6OjW37+dv1Da7f1rX39/Px8TExM5GcEZWe/rP3sjo6OfMuibWTA80qYAWjT2mrN0tJSLC0trbsRHhoaiqGhoZiZmYnr169HsViMsbGxLZvWN7qZbvUGu5WDH7P/tjIMoNUJY+18/m6EqbXh8YUXXojr16/HyZMn275pbzVcZdfc6vVZwN2o8X9tSNnsz2izqlSj0Yjp6em4f/9+lEqlOHbsWN6T0/z/vVB4dNhruVzelXAH8KwTZgB2oFgs5uOda7VaLC0trTr1vlAoRF9fX/T19eU/Ua/VajE8PBz9/f35DehmIWazJvONtBoUWh0GsNHnP41DQrezdg3lcjlGR0fj+vXrcfz48bYCU7sDFTabCBYRcfv27RgbG2vpOlsFo+bHsyl62Va648ePR7FYXDWJLOLR30PN/MB+JMwA7JLOzs68qTqr1jQajfzsmoMHD0alUol6vR7379+PP//8M3p7e2N4eHhVtWajrUabjUZufm4ruzHy90kcirmTtTR/L729vbG8vLxuIMBurGOr8dOZ+fn5aDQa6/pWHudzC4VCzM3Nxd27d6PRaMTIyMi6kJRVYLLpd81bGAH2E2EG4AnIfkoeEVGr1WJ5eTk/J6arqytGR0fzwzcnJyejVqvFwMBA9Pf3b3hjurYZfO3wgey5zc6T2e2m71Z6P9Ze/3FDRatbwYaGhuL27dtx586dvG9lu2u228Oz0esbjUb8+++/ceLEiZY/ZyPVajXu378fCwsLUalU4siRI6vGOxcKhXyccmdnpwADEMIMwBOXVWyyrWjLy8v5RLSDBw/m59pMTU3FP//8Ex0dHdHf3x8DAwObnnOydpvRVtvVdsNGzeXtXKvdvp9m7YxNHh8fjxs3bsTdu3djZGRk22ttNzGslcM/b926FaOjo4/Vo1Kr1fJtZOVyOQYHB+Pw4cOremuyRn4VGID1hBmAp6g52DQajTzYREQMDw/HyMhI3idx5cqVKJVKec/N2l6IdqstrTb+Z70+W11rq0EFO6107ESh8OhAzZs3b8bk5OSmPSzZa5t/v9H3vt3UuZmZmVhZWYn+/v5t15Z9r0tLSzE1NRWzs7NRLBZjYGAgTp06tSqQZqOUu7q69MAAbEGYAdgjHR0dUS6Xo1wu5+Oes1HP2Ta07Mb377//zocJ9Pf3R1dX16rwsLZJ/XGnorVSrdhMK30724Wkdt671TpeeOGFuH37dty+fTsOHz687vlWeo+2uubKykosLi7G5ORkHkSaq2UbjVOenp6Oubm5KJVKMTAwECMjI/m5Oln1pbnvCoDt+RcT4BnQPO454tHhi/V6PT8n5NChQ9FoNGJmZiZu3rwZ9Xo9uru7o6+vL3p6elb99H63tpq1GmraGW+807W04/DhwzE5ORnXr1+PY8eO5X9GrfbzbHXNxcXFfHra2i13hUIhlpeXY25uLqanp6NWq0WlUon+/v4YHx/Pw0sWXLq6una9pwlgvxBmAJ5BxWIxH7cb8ajJfGlpKQ4cOBDDw8NRr9djfn4+Zmdn486dOxER0d3dHb29vdHd3d1SlaTVvpfsZn+782Va0c7ggI36VbZa70bPj42NxdTUVFy9ejWOHTuWHzDZLJs21+p2ruYgk/XJ1Ov1mJubi7m5uVhYWIiurq44ePBgHD16NEqlUhQKhTy8dHZ22joGsEuEGYAEdHR0rLoRr9Vq0dPTE4ODg1Gv16NWq+WVgImJiYiIqFQq0dPTEz09PVEsFlvqBcme26h6sdbjVGy2Cz7NN/mt9Om08vzAwEB0d3fHjRs3oq+vLw4dOrRujZtVbdZ+/sOHD2NiYiLGxsZidnY25ufno1qtRmdnZ/T09MTw8HBUKpVVlZfOzk6VF4AnRJgBSFDWV9E8ure3tzdGR0ejVqvl4ebhw4dx7969qNfr+Q13d3d3VCqVPOCs7b1pdZvadjfoj3MD32g0Nnx8q2lj2bW2ClelUilOnToVk5OTcfny5RgZGVk1LW6j6XCZxcXFmJubi2vXrsXi4mIMDw/H9PR0HDx4MEZHR6NSqeSTxrJfADwdwgzAcyKrAmQHcPb390etVot6vR6NRiOq1Wq+Feq///7LJ3eVSqU84JTL5U23QG10xs3a53Zqs2u3ssWtleuPjY3FyMhI3Lt3L/76668YHByM3t7eKJfLsby8HNVqNarVaiwsLMTy8nIsLCxEtVqNer0eL730UoyPj0dHR0cUi0XbxQCeAcIMwHOseTpWpVKJwcHBWFlZyQcMZL03c3Nz8eDBg6hWqxHxKJx0dXVFqVSKAwcORKlUyr/OqjftBonsdVtVfrL+lVanirXz+dko7GxbWKVSiRs3bsTDhw9jaWkpnyxXLpeju7s7yuVyDA0NxcjISPT29rZ0fQCeLmEGYJ9pbkaPeDQ4IDtgstFo5JWcpaWlWFhYiIWFhZiZmckrFFlFp/kwx2ybVXYyffZcVsnJbBSEWllvs+b3Z4Esq0Bl462zw0lrtVoebppHYZfL5RgfH48XX3wxr7A098+ouACkQZgBINd8I18ul9dVJLKelqzKUavVYnFxMT/8M9uatbi4mIeM7DDKzNq+lOawUq1W48qVK+t6WdZ+ncnOZimXy/n0t56eniiVSvnj2fckoAA8f4QZAFqWBYJsWldEtLwFa7Pm/ubHe3t74/Tp0/nXa6syAgkAzYQZAJ6KzYJI8+OmgQHQDj/iAgAAkiTMAAAASRJmAACAJAkzAABAkoQZAAAgScIMAACQJGEGAABIkjADAAAkSZgBAACSJMwAAABJEmYAAIAkCTMAAECShBkAACBJwgwAAJAkYQYAAEiSMAMAACRJmAEAAJIkzAAAAEkSZgAAgCQJMwAAQJKEGQAAIEnCDAAAkCRhBgAASJIwAwAAJEmYAQAAkiTMAAAASRJmAACAJAkzAABAkoQZAAAgScIMAACQJGEGAABIkjADAAAkSZgBAACSJMwAAABJEmYAAIAkCTMAAECShBkAACBJwgwAAJAkYQYAAEiSMAMAACRJmAEAAJIkzAAAAEkSZgAAgCQJMwAAQJKEGQAAIEnCDAAAkCRhBgAASJIwAwAAJEmYAQAAkiTMAAAASRJmAACAJAkzAABAkoQZAJ4ZH3744V4vAYCEFFZWVlp9bcsvBAAA2KHCdi9QmQEAAJIkzAAAAEkSZgAAgCQJMwAAQJKEGQAAIEnCDAAAkCRhBgAASJIwAwAAJEmYAQAAkiTMAAAASRJmAACAJAkzAABAkoQZAAAgScIMAACQJGEGAABIkjADAAAkSZgBAACSJMwAAABJEmYAAIAkCTMAAECShBkAACBJwgwAAJAkYQYAAEiSMAMAACRJmAEAAJIkzAAAAEkSZgAAgCQJMwAAQJKEGQAAIEnCDAAAkCRhBgAASJIwAwAAJEmYAQAAkiTMAAAASRJmAACAJAkzAABAkoQZAAAgScIMAACQJGEGAABIkjADAAAkSZgBAACSJMwAAABJEmYAAIAkCTMAAECShBkAACBJwgwAAJAkYQYAAEiSMAMAACRJmAEAAJIkzAAAAEkSZgAAgCQJMwAAQJKEGQAAIEnCDAAAkCRhBoB94ZdffomPP/44Ll68uNdLAWCXCDMAPJOuXbsWhUIh3nzzzXXPXbhwIT777LN477334siRI1EoFKJQKMTNmzc3/bzx8fH4+uuv48svv3yCqwbgaerc6wUAQLs++uijmJ6ebus9J0+ejFdffTUuXboUs7Oz0dvb+4RWB8DTojIDQHI++OCD+OKLL+LHH3+MO3futPy+s2fPxtLSUly4cOEJrg6Ap0WYASA533zzTXzyySfxzjvvxKFDh1p+39mzZyMi4ty5c09mYQA8VcIMAPvG6dOn4/jx4/HDDz/E8vLyXi8HgB0SZgDYV86cORPT09Nx6dKlvV4KADskzACwr9hqBvD8EGYA2FfeeOONGBoaiu+++y5WVlb2ejkA7IAwA8C+UiwW4913341bt27Fb7/9ttfLAWAHhBkA9p3//e9/ERFx48aNPV4JADshzACw75w/fz5KpVK8/fbbe70UAHZAmAFgX7l27Vr88ccf8dZbb0VfX99eLweAHRBmANhXsilm2VQzANIlzACwr5w7dy4KhUKcOXNmr5cCwA517vUCAKBdn3/+eXz//ffrHn///fejVCpFRMRrr70WX3311arn7927Fz///HO8/vrrcfjw4aeyVgCeHGEGgORcuXIlfv3113WP//777/nvDxw4sO758+fPR71et8UM4DlhmxkAyfn2229jZWVly18//fTTuvfplwF4vggzAOwL8/PzcfHixXj55ZfjlVde2evlALALhBkA9oWLFy/GwsKCqgzAc0TPDAD7wtmzZ2NlZWWvlwHALlKZAQAAkqQyA8AzaWBgID799NM4ceLEXi8FgGdUoY2Su9o8AADwtBS2e4FtZgAAQJKEGQAAIEnCDAAAkCRhBgAASJIwAwAAJEmYAQAAkiTMAAAASRJmAACAJAkzAABAkoQZAAAgScIMAACQJGEGAABIkjADAAAkSZgBAACSJMwAAABJEmYAAIAkdbbx2sITWwUAAECbVGYAAIAkCTMAAECShBkAACBJwgwAAJAkYQYAAEiSMAMAACRJmAEAAJIkzAAAAEkSZgAAgCT9HwTvGcJ59BkFAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 设置随机种子\n",
    "np.random.seed(42)\n",
    "# 采样的次数\n",
    "num_samples = 15\n",
    "# 存储采样得到的量子态\n",
    "state = []\n",
    "\n",
    "for i in range(num_samples):\n",
    "    \n",
    "    # 创建单比特量子的线路\n",
    "    cir = UAnsatz(1)\n",
    "    # 生成随机的旋转角度\n",
    "    phi, theta, omega = 2 * np.pi * np.random.uniform(size=3)\n",
    "    phi = paddle.to_tensor(phi, dtype='float64')\n",
    "    theta = paddle.to_tensor(theta, dtype='float64')\n",
    "    omega = paddle.to_tensor(omega, dtype='float64')\n",
    "    \n",
    "    # 对单比特量子态做随机的旋转操作\n",
    "    cir.rz(phi, 0)\n",
    "    cir.ry(theta, 0)\n",
    "    cir.rz(omega, 0)\n",
    "    \n",
    "    # 将线路的末态存储起来\n",
    "    state.append(cir.run_state_vector())\n",
    "\n",
    "# 调用布洛赫球面展示功能，输入state参数，并且展示向量\n",
    "plot_state_in_bloch_sphere(state, show_arrow=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上图所示，我们随机采样了 15 次，生成了 15 个随机的单比特量子态，将这 15 个量子态分别展示在布洛赫球面上，便可得到效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量桨中对布洛赫球面的刻画有着丰富的功能，能够提供不同角度，不同视角距离的布洛赫球面展示。并且支持动态 gif 图的存储，方便学者们理解和学习。\n",
    "\n",
    "调用更加丰富的布洛赫球面功能请参考 `utils.plot_state_in_bloch_sphere()` 函数 API。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 示例: 如何在布洛赫球面上刻画单比特量子态旋转的\"轨迹\"？\n",
    "\n",
    "更进一步地，我们知道对单比特量子的酉算子操作，实际上可以认为是对布洛赫球面上的一个已知的布洛赫球向量做对某个轴的旋转操作。量子线路的初态对应布洛赫球面上最初的布洛赫球向量，量子线路的末态则对应布洛赫球面上旋转完成之后的布洛赫球向量。\n",
    "\n",
    "假设我们把一个从 $|0\\rangle$ 态经过了 $R_y(\\frac{\\pi}{4})$ 旋转门、$R_z(\\frac{\\pi}{2})$ 旋转门之后得到状态作为量子态的初始状态，把 $U3(\\theta = \\frac{\\pi}{2}, \\phi = \\frac{7\\pi}{8}, \\lambda = 2\\pi)$ 旋转门作为即将要做的酉算子操作，想用布洛赫球面来清晰地刻画这个酉算子操作的过程，需要如何做呢？\n",
    "\n",
    "在量桨中，我们可以把对单比特量子所做的酉算子操作，在布洛赫球面上通过生动形象的\"转动轨迹\"来展示。同样地，我们采用量桨里 `utils` 包的函数，通过输入量子态的初始状态 `init_state` 和 $U3$ 旋转门的角度，便可以实现这一效果。\n",
    "\n",
    "具体代码如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建单比特量子的线路\n",
    "cir = UAnsatz(1)\n",
    "\n",
    "# 设置量子态的初始状态\n",
    "cir.ry(paddle.to_tensor(np.pi/4, dtype=\"float64\"), 0)\n",
    "cir.rz(paddle.to_tensor(np.pi/2, dtype=\"float64\"), 0)\n",
    "init_state = cir.run_density_matrix()\n",
    "\n",
    "# 将要进行的酉算子操作\n",
    "theta = np.pi/2\n",
    "phi = 7*np.pi/8\n",
    "lam = 2*np.pi\n",
    "rotating_angle = [theta, phi, lam]\n",
    "\n",
    "# 调用布洛赫球面展示功能，输入初始状态init_state，酉算子的旋转角度rotating_angle\n",
    "plot_rotation_in_bloch_sphere(init_state, rotating_angle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如上图所示，偏右边的布洛赫球向量为初始量子态所对应的布洛赫球向量，偏左边的布洛赫球向量为做完酉算子之后的量子态所对应的布洛赫球向量。中间红色的点阵为量子态在做酉算子过程中所经过的\"轨迹\"。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量桨中对布洛赫球面的\"轨迹\"刻画同样有着丰富的功能，能够提供不同角度，不同视角距离的布洛赫球面展示。并且支持动态 gif 图的存储，方便学者们理解和学习。\n",
    "\n",
    "调用更加丰富的布洛赫球面功能请参考 `utils.plot_rotation_in_bloch_sphere()` 函数 API。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"gate\">什么是量子逻辑门？</a>\n",
    "\n",
    "在经典计算机中，我们可以在经典比特上施加基本的逻辑运算（非门 NOT, 与非门 NAND, 异或门 XOR, 与门 AND, 或门 OR）并组合成更复杂的运算。而量子计算则有完全不同的一套逻辑运算，它们被称为量子门 (quantum gate)。我们并不能在一个量子计算机上编译现有的C++程序。因为**经典计算机和量子计算机有不同的逻辑门构造，所以量子算法是需要利用这些量子门的特殊性来构造的**。量子门在数学上可以被表示成酉矩阵（unitary matrix）。酉矩阵操作可以保证向量的长度不变，这是个很好的性质。不然我们对一个纯态量子比特进行操作，会让它劣化成混合态导致其无法接着很好地使用。酉矩阵定义为：\n",
    "\n",
    "$$\n",
    "U^{\\dagger}U = UU^{\\dagger} = I, \n",
    "\\quad \\text{并且} \\quad \n",
    "\\Vert |\\psi\\rangle \\Vert  = \\Vert U|\\psi\\rangle\\Vert = 1.\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "其中 $U^{\\dagger}$ 是 $U$ 的共轭转置，$I$ 表示单位矩阵。但是酉矩阵作为量子门的物理意义是什么？这意味着**所有的量子门都必须是可逆的**。对于任何一个量子门运算，都可以找到一个与其对应的反向运算。除此之外，酉矩阵必须是个方阵。因为量子门的输入和输出要求有同样数量的量子比特。一个作用在 $n$ 量子比特的量子门可以写成一个 $2^n \\times 2^n$ 的酉矩阵。最常见的（也是物理上最容易实现的）量子门作用在一个或两个量子比特上，就像经典逻辑门那样。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单量子比特门\n",
    "\n",
    "接下来，我们介绍在量子计算中非常重要的单量子比特门，包括泡利矩阵 $\\{X, Y, Z\\}$、单比特旋转门 $\\{R_x, R_y, R_z\\}$ 和 Hadamard 门 $H$。其中 **非门（NOT gate）** 对于经典或量子计算都很重要，酉矩阵表示为：\n",
    "\n",
    "$$\n",
    "X := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix}.\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "这个量子门（酉矩阵）作用在单量子比特（一个复向量）上本质上的运算是**矩阵乘以向量**：\n",
    "\n",
    "$$\n",
    "X |0\\rangle := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} \\begin{bmatrix} 1 \\\\0 \\end{bmatrix} \n",
    "=\\begin{bmatrix} 0 \\\\1 \\end{bmatrix} = |1\\rangle, \n",
    "\\quad \n",
    "X |1\\rangle := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} \\begin{bmatrix} 0 \\\\1 \\end{bmatrix} \n",
    "=\\begin{bmatrix} 1 \\\\0 \\end{bmatrix}=|0\\rangle.\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "回忆起前面的布洛赫球面表示，这个矩阵 $X$ 作用在一个量子比特（布洛赫球面上的一点）就相当于**关于布洛赫球的 $x$ 轴旋转角度 $\\pi$**。这就是为什么 $X$ 可以表示成 $R_x(\\pi)$（相差全局相位 $e^{-i\\pi/2} = -i$）。其他两个泡利矩阵 $Y$ 和 $Z$ 在这一点上也非常相似（代表绕 $y$ 和 $z$ 轴旋转 $\\pi$ 角度 ）：\n",
    "\n",
    "$$\n",
    "Y := \\begin{bmatrix} 0 &-i \\\\ i &0 \\end{bmatrix},\n",
    "\\quad \n",
    "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix}.\n",
    "\\tag{9}\n",
    "$$\n",
    "\n",
    "一般来说，任何一个在布洛赫球关于相应的轴旋转 $\\theta$ 角度的量子门可以表示为：\n",
    "\n",
    "$$\n",
    "R_x(\\theta) := \n",
    "\\begin{bmatrix} \n",
    "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\ \n",
    "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_y(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\ \n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_z(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta}{2}}\n",
    "\\end{bmatrix}.\n",
    "\\tag{10}\n",
    "$$\n",
    "\n",
    "除了旋转门之外，最重要的单比特门就是 Hadamard 门了。对应的布洛赫球面解释是两个旋转组成的，先是按 $z$ 轴旋转 $\\pi$，然后按 $y$ 轴旋转 $\\pi/2$。它的矩阵表示是\n",
    "\n",
    "$$\n",
    "H := \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 &1 \\\\ 1 &-1 \\end{bmatrix}.\n",
    "\\tag{11}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 两比特量子门\n",
    "\n",
    "从单量子比特门我们可以拓展到两量子比特门。有两种拓展方式，第一种是只挑选出一个量子比特，在上面施加单量子比特门，其他的量子比特则不进行任何操作。有的时候，会见到如下图所示的量子电路："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-hadamard.png\" width=\"600\" >\n",
    "\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;  \n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;\n",
    "**图 2.** \n",
    "两量子比特逻辑运算的电路表示和解读。[[图片来源]](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "作用在两量子比特上的量子门可以表示成一个 $4\\times4$ 酉矩阵：\n",
    "\n",
    "$$\n",
    "U = H \\otimes I \n",
    "= \\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 &1 \\\\ 1 &-1 \\end{bmatrix} \n",
    "\\otimes \\begin{bmatrix} 1 &0 \\\\ 0 &1 \\end{bmatrix} \n",
    "= \\frac{1}{\\sqrt{2}} \\,\n",
    "\\begin{bmatrix}\n",
    "1 &0 &1 &0  \\\\ \n",
    "0 &1 &0 &1  \\\\\n",
    "1 &0 &-1 &0 \\\\\n",
    "0 &1 &0 &-1 \n",
    "\\end{bmatrix}.\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "另一种拓展方式是将逻辑门直接作用在两个量子比特上。比如受控非门 $\\text{CNOT}$，这个门会使得一个量子比特的状态影响到另一个量子比特的状态\n",
    "\n",
    "$$\n",
    "\\text{CNOT} := \n",
    "\\begin{bmatrix} \n",
    "1 &0 &0 &0 \\\\ \n",
    "0 &1 &0 &0 \\\\\n",
    "0 &0 &0 &1 \\\\\n",
    "0 &0 &1 &0 \n",
    "\\end{bmatrix}.\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "我们观察一下它作用在不同的初始量子态上：\n",
    "\n",
    "$$\n",
    "\\text{CNOT} |00\\rangle = |00\\rangle, \\quad\n",
    "\\text{CNOT} |01\\rangle = |01\\rangle, \\quad\n",
    "\\text{CNOT} |10\\rangle = |11\\rangle, \\quad\n",
    "\\text{CNOT} |11\\rangle = |10\\rangle.\n",
    "\\tag{14}\n",
    "$$\n",
    "\n",
    "也就是说，当第一个量子比特处于 $|1\\rangle$ 状态时，$\\text{CNOT}$ 会在第二个量子比特上施加 $X$ 门，如果第一个量子比特处于 $|0\\rangle$ 状态，那么第二个量子比特则不受任何影响。这也是为什么 $\\text{CNOT}$ 会被称为受控非门。下面是一些常见的量子门及它们的矩阵表示，**这些量子门都可以在量桨内被调用**。\n",
    "\n",
    "![intro-fig-gates](./figures/intro-fig-gates.png \"**图 3.** 常见的量子门. [[图片来源]](https://en.wikipedia.org/wiki/Quantum_logic_gate)\")\n",
    "\n",
    "**注**：更多信息可见如下维基百科 [链接](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"measure\">什么是量子力学中的测量？</a>\n",
    "\n",
    "对于一个两分类的量子态，比如电子的自旋（Spin），我们规定该电子自旋向上 $\\uparrow$ 时记为 $|0\\rangle$ 态，自旋向下 $\\downarrow$ 时记为 $|1\\rangle$ 态。神奇的是，电子等微观粒子在被观测之前可以同时处于自旋向上和自旋向下的叠加态 $|\\psi\\rangle =\\alpha |0\\rangle  + \\beta |1\\rangle$。那么这个叠加态到底指的是什么呢？答案很简单，我们可以去测量一下这个处于\"叠加态\"的电子。值得注意的是，量子力学中的测量通常指的是一个统计结果而不是单次测量。这是由于测量本身的特性会使得观察后的量子态塌缩。就拿我们前面提到的处于 $|\\psi\\rangle$ 态的这个电子来举例，如果我们测量这一个电子的自旋，我们会有 $|\\alpha|^2$ 的概率观测到自旋向上并且观测后量子态塌缩成 $ |0\\rangle$。同样的，我们也有 $|\\beta|^2$ 的概率测量得到自旋向下$|1\\rangle$。那么想要精确的得到 $\\alpha$ 的数值，一次实验显然是不够的。我们需要拜托物理学家朋友准备了好多好多处于叠加态 $\\alpha |0\\rangle  + \\beta |1\\rangle$ 的电子，把每一个的自旋都测量再统计频率。测量在量子力学中地位比较特殊，如果读者觉得难理解。请参阅 [维基百科-量子力学中的测量](https://en.wikipedia.org/wiki/Measurement_in_quantum_mechanics#:~:text=In%20quantum%20physics%2C%20a%20measurement,makes%20are%20in%20general%20probabilistic.) 获取更多知识。\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##    <a name=\"ex1\">示例以及练习</a>\n",
    "\n",
    "### 示例: 用 Paddle Quantum 创建 $X$ 门\n",
    "\n",
    "**注意:** 所有的单比特旋转门都按如下规定建立：\n",
    "\n",
    "$$\n",
    "R_x(\\theta) := \n",
    "\\begin{bmatrix} \n",
    "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\ \n",
    "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_y(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\ \n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    ",\\quad \n",
    "R_z(\\theta) := \n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta}{2}}\n",
    "\\end{bmatrix}.\n",
    "\\tag{15}\n",
    "$$\n",
    "\n",
    "因此，我们不难看出 $X$ 门可以表示为 $R_x(\\pi)$。以下是代码展示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:19:01.589007Z",
     "start_time": "2021-04-30T09:19:01.468170Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "量子门的矩阵表达式为：\n",
      "[[ 6.123234e-17+0.j -6.123234e-17-1.j]\n",
      " [ 6.123234e-17-1.j  6.123234e-17+0.j]]\n"
     ]
    }
   ],
   "source": [
    "# 设置角度参数 theta = pi\n",
    "theta = np.array([np.pi])\n",
    "    \n",
    "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "theta = paddle.to_tensor(theta)\n",
    "\n",
    "# 设置计算所需的量子比特数量\n",
    "num_qubits = 1\n",
    "\n",
    "# 初始化我们的单比特量子电路\n",
    "cir = UAnsatz(num_qubits)\n",
    "\n",
    "# 在第一个量子比特(第0号量子比特)的位置上施加一个 Rx 旋转门， 角度为 pi\n",
    "which_qubit = 0\n",
    "cir.rx(theta, which_qubit)\n",
    "\n",
    "# 打印出这个量子门\n",
    "# 转换成 numpy \n",
    "print('量子门的矩阵表达式为：')\n",
    "print(cir.U.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "结果和 $X$（NOT）门只相差一个全局相位$-i$\n",
    "\n",
    "$$\n",
    "\\text{output} = \\begin{bmatrix} 0 &-i \\\\ -i &0 \\end{bmatrix}\n",
    "= -i\\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} = -i X.\n",
    "\\tag{16}\n",
    "$$\n",
    "\n",
    "有兴趣的话，你可以仔细思考一下为什么在量子计算中，全局相位并不重要。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 练习: 创建 $Y$ 门\n",
    "\n",
    "那么按照以上的例子依葫芦画瓢，你是否可以试着自己创建一个 $Y$ 门？试着补全下面的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = \"your code\"\n",
    "    \n",
    "theta = paddle.to_tensor(theta)\n",
    "num_qubits = 1\n",
    "cir = UAnsatz(\"your code\")\n",
    "cir.ry(\"your code\")\n",
    "print(cir.U.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和原来一样，我们还是多了一个全局相位\n",
    "\n",
    "$$\n",
    "\\text{output} = \\begin{bmatrix} 0 &-1 \\\\ 1 &0 \\end{bmatrix}\n",
    "= -i\\begin{bmatrix} 0 &-i \\\\ i &0 \\end{bmatrix} = -i Y.\n",
    "\\tag{17}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"VA\">量子电路模板/量子神经网络</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "经过上面的准备，你现在有一定的知识基础可以了解量子机器学习了。简单来说，我们要做的就是利用参数化量子电路（Parametrized Quantum Circuit, PQC）来替代传统的神经网络来完成机器学习的任务。处理的对象可以是经典数据也可以是量子数据。我们一般会准备一个可调节参数的量子电路（PQC），也被称作量子神经网络（Quantum Neural Network, QNN）或者电路模板（ansatz），里面的参数是人为可调节的（这些参数大多数情况下就是旋转门的角度 $\\theta$）。例如上一节中看到的用参数 $\\pi$ 构造 $X$ 门，这其实就是最简单的量子神经网络。如果再加上一个精心设计的损失函数，就可以将一个计算问题转化为寻找损失函数的最值问题。然后不断调节电路中的参数直到损失函数下降至收敛（此时损失函数达到最优值或次优值），我们就完成了优化。这样的一种在量子设备上估值损失函数然后在经典设备上进行优化的框架被称为量子-经典混合优化，或者变分量子算法（Variational Quantum Algorithms, VQA）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"QNN\">示例: 如何创建量子神经网络 QNN？</a>\n",
    "\n",
    "QNN 通常可以表示为一些单比特量子旋转门和双比特门的组合。其中一个可以高效利用硬件的架构是只包含 $\\{R_x, R_y, R_z, \\text{CNOT}\\}$ 这四种量子门的模板。它们很容易在 NISQ （Noisy-Intermidiate-Scale-Quantum）设备（通常是超导量子比特）上实现，因为 $\\text{CNOT}$ 只需要实施在相邻量子比特上。一个例子可见下图：\n",
    "\n",
    "\n",
    "![intro-fig-gate1](./figures/intro-fig-gate1.png)\n",
    "\n",
    "通常来说，每条线代表一个量子比特。我们把图最上端的认为是第一个量子比特 $q_0$，依次往下。从左到右代表我们施加门的时间顺序，先施加最左边的量子门。接下来，我们来看看如何在量桨上建造这个简单的两比特量子神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:19:07.433031Z",
     "start_time": "2021-04-30T09:19:07.409641Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "图中量子神经网络 U(theta=pi) 的矩阵表达式是:\n",
      "[[ 0.0000000e+00 -1.0000000e+00  6.1232340e-17 -6.1232340e-17]\n",
      " [-1.0000000e+00  0.0000000e+00 -6.1232340e-17  6.1232340e-17]\n",
      " [-6.1232340e-17  6.1232340e-17  1.0000000e+00  1.2246468e-16]\n",
      " [ 6.1232340e-17 -6.1232340e-17 -1.2246468e-16  1.0000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "# 设置角度参数 theta \n",
    "theta = np.full([4], np.pi)\n",
    "    \n",
    "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "theta = paddle.to_tensor(theta)\n",
    "\n",
    "# 初始化量子电路\n",
    "num_qubits = 2\n",
    "cir = UAnsatz(num_qubits)\n",
    "\n",
    "# 添加单比特旋转门\n",
    "cir.ry(theta[0], 0)\n",
    "cir.ry(theta[1], 1)\n",
    "\n",
    "# 添加两比特门\n",
    "cir.cnot([0, 1])\n",
    "\n",
    "# 添加单比特旋转门\n",
    "cir.ry(theta[2], 0)\n",
    "cir.ry(theta[3], 1)\n",
    "\n",
    "print('图中量子神经网络 U(theta=pi) 的矩阵表达式是:')\n",
    "print(cir.U.numpy().real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\text{output} = \n",
    "\\begin{bmatrix} \n",
    "0  &-1 &0 &0 \\\\ \n",
    "-1 &0  &0 &0 \\\\\n",
    "0  &0  &1 &0 \\\\\n",
    "0  &0  &0 &1 \n",
    "\\end{bmatrix}.\n",
    "\\tag{18}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 练习\n",
    "\n",
    "给你如下代码，你能想象出对应的电路吗？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-04-30T09:19:17.518832Z",
     "start_time": "2021-04-30T09:19:17.507574Z"
    }
   },
   "outputs": [],
   "source": [
    "theta = np.full([6], np.pi)\n",
    "    \n",
    "theta = paddle.to_tensor(theta)\n",
    "\n",
    "num_qubits = 3\n",
    "cir = UAnsatz(num_qubits)  \n",
    "\n",
    "cir.ry(theta[0], 0)\n",
    "cir.ry(theta[1], 1)\n",
    "cir.ry(theta[2], 2)\n",
    "\n",
    "cir.cnot([0, 1])\n",
    "cir.cnot([1, 2])\n",
    "\n",
    "cir.ry(theta[3], 0)\n",
    "cir.ry(theta[4], 1)\n",
    "cir.ry(theta[5], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "答案如下:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-gate2.png\" width=\"450\" >\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以使用量桨中打印电路的功能查看构造好的电路："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(3.1416)----*----Ry(3.1416)----------------\n",
      "                |                              \n",
      "--Ry(3.1416)----X---------*--------Ry(3.1416)--\n",
      "                          |                    \n",
      "--Ry(3.1416)--------------X--------Ry(3.1416)--\n",
      "                                               \n"
     ]
    }
   ],
   "source": [
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"Ansatz\">内置的电路模板</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在最新版本的 Paddle Quantum 中，我们提供了一些内置的电路模板方便场景部署。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:12.042782Z",
     "start_time": "2021-03-09T03:53:11.531307Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEPCAYAAABY9lNGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZJElEQVR4nO3df5xddX3n8debn6JYfhmpkmhoidpQlGpEH+3WqijCY9VgBQ26FVwsdpVteai1cWtRqbuVVsW64tZ0URFXA0v9kS1RdEXrrhUkID8aIBL5GdQafiqyiJHP/nFOyM2dMzN3hty5l+T1fDzmMfee7zkz75k/5j3nfM+PVBWSJPXbadQBJEnjyYKQJHWyICRJnSwISVInC0KS1GmXUQfYVh73uMfVwoULRx1Dkh5RLrvsstural7X2HZTEAsXLmTNmjWjjiFJjyhJbp5szENMkqROFoQkqZMFIUnqZEFIkjpZEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE7bzZXUD9fC5ReM7Hvf9L5/O+W42bqZbXbMNjuP5Gyz5R6EJKmTBSFJ6mRBSJI6WRCSpE5DLYgkRyZZl2R9kuUd489LcnmSTUmO6Vl+aJJvJ1mb5Kokrx5mTknSREMriCQ7A2cCRwGLgeOSLO5b7RbgBOAzfcvvA15XVQcDRwIfSrL3sLJKkiYa5mmuhwHrq+oGgCQrgaXANZtXqKqb2rEHezesqu/1vP5Bkh8D84C7h5hXktRjmIeYDgBu7Xm/oV02I0kOA3YDvt8xdlKSNUnWbNy4cdZBJUkTjfUkdZInAOcAr6+qB/vHq2pFVS2pqiXz5nU+UlWSNEvDLIjbgAU97+e3ywaS5FeAC4A/r6qLt3E2SdI0hlkQlwKLkhyYZDdgGbBqkA3b9T8PfKqqzh9iRknSJIZWEFW1CTgZuBC4FjivqtYmOS3JywGSPDvJBuBY4GNJ1rabvwp4HnBCkivaj0OHlVWSNNFQb9ZXVauB1X3LTu15fSnNoaf+7T4NfHqY2SRJUxvrSWpJ0uhYEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqZEFIkjpZEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqNNSCSHJkknVJ1idZ3jH+vCSXJ9mU5Ji+seOTXN9+HD/MnJKkiYZWEEl2Bs4EjgIWA8clWdy32i3ACcBn+rbdF3gX8BzgMOBdSfYZVlZJ0kTD3IM4DFhfVTdU1QPASmBp7wpVdVNVXQU82LftS4CvVtWdVXUX8FXgyCFmlST1GWZBHADc2vN+Q7tsm22b5KQka5Ks2bhx46yDSpImekRPUlfViqpaUlVL5s2bN+o4krRdGWZB3AYs6Hk/v1027G0lSdvAMAviUmBRkgOT7AYsA1YNuO2FwBFJ9mknp49ol0mS5sjQCqKqNgEn0/xhvxY4r6rWJjktycsBkjw7yQbgWOBjSda2294J/CVNyVwKnNYukyTNkV2G+cWrajWwum/ZqT2vL6U5fNS17ceBjw8znyRpco/oSWpJ0vBYEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqZEFIkjpZEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqdNABZHkd5I8pn3975J8MMmThxtNkjRKg+5B/DfgviTPAN4KfB/41HQbJTkyybok65Ms7xjfPcm57fglSRa2y3dNcnaSq5Ncm+Qdg/9IkqRtYdCC2FRVBSwFPlJVZwKPnWqDJDsDZwJHAYuB45Is7lvtROCuqjoIOAM4vV1+LLB7VR0CPAt44+bykCTNjUEL4qftf/F/AFyQZCdg12m2OQxYX1U3VNUDwEqagum1FDi7fX0+cHiSAAU8JskuwB7AA8BPBswqSdoGBi2IVwM/B/59Vf0ImA/8zTTbHADc2vN+Q7usc52q2gTcA+xHUxY/A34I3AK8v6ru7P8GSU5KsibJmo0bNw74o0iSBjFQQbSl8A/A7u2i24HPDysUzd7HL4EnAgcCb03yax25VlTVkqpaMm/evCHGkaQdz6BnMf0hzX/1H2sXHQB8YZrNbgMW9Lyf3y7rXKc9nLQXcAfwGuDLVfWLqvox8C1gySBZJUnbxqCHmN4M/A7tPEBVXQ88fpptLgUWJTkwyW7AMmBV3zqrgOPb18cAF7WT4bcALwRoT699LnDdgFklSdvAoAXx83aiGXjov/2aaoN2TuFk4ELgWuC8qlqb5LQkL29XOwvYL8l64C3A5lNhzwT2TLKWpmg+UVVXDfpDSZIevl0GXO+fkvwnYI8kLwbeBPyv6TaqqtXA6r5lp/a8vp/mlNb+7e7tWi5JmjuD7kEsBzYCVwNvpPmj/85hhZIkjd5AexBV9SDw9+2HJGkHMGVBJDmvql6V5Go65hyq6ulDSyZJGqnp9iD+pP380mEHkSSNlynnIKrqh+3LN1XVzb0fNBPVkqTt1KCT1C/uWHbUtgwiSRov081B/AeaPYVfS9J7HcJjaa5uliRtp6abg/gM8CXgr9hyERvAT7tunidJ2n5MVxBVVTcleXP/QJJ9LQlJ2n4NsgfxUuAymtNc0zNWwIQ7rEqStg9TFkRVvbT9fODcxJEkjYvpJqmfOdV4VV2+beNIksbFdIeYPjDFWNHekluStP2Z7hDTC+YqiCRpvEx3iOmFVXVRkt/vGq+qzw0nliRp1KY7xPR7wEXAyzrGCrAgJGk7Nd0hpne1n18/N3EkSeNioHsxJdkvyYeTXJ7ksiR/m2S/YYeTJI3OoDfrW0nzRLlXAse0r88dVihJ0ugN+kzqJ1TVX/a8f2+SVw8jkCRpPAy6B/GVJMuS7NR+vAq4cJjBJEmjNd1prj9lyz2YTgE+3Q7tBNwLvG2Y4SRJozPdWUyPnasgkqTxMugcBEn2ARYBj9q8rKq+OYxQkqTRG/Q01zcA36SZd3hP+/ndA2x3ZJJ1SdYnWd4xvnuSc9vxS5Is7Bl7epJvJ1mb5Ookj+rfXpI0PINOUv8J8Gzg5vb+TL8F3D3VBkl2Bs6keXb1YuC4JIv7VjsRuKuqDgLOAE5vt92FZr7jj6rqYOD5wC8GzCpJ2gYGLYj7q+p+aP7rr6rrgKdOs81hwPqquqGqHqC5lmJp3zpLgbPb1+cDhycJcARwVVVdCVBVd1TVLwfMKknaBgYtiA1J9ga+AHw1yReBm6fZ5gDg1t6v0S7rXKeqNgH3APsBTwEqyYXt1dtv7/oGSU5KsibJmo0bNw74o0iSBjHQJHVVvaJ9+e4kXwf2Ar48tFRNrn9Dc1jrPuBrSS6rqq/15VoBrABYsmRJDTGPJO1wBt2DIMkzk/wx8HRgQ3vYaCq3AQt63s9vl3Wu08477AXcQbO38c2qur2q7gNWA1M+3U6StG0NehbTqTRzBfsBjwM+keSd02x2KbAoyYFJdgOWAav61lkFHN++Pga4qKqK5iypQ5I8ui2O3wOuGSSrJGnbGPQ6iNcCz+iZqH4fcAXw3sk2qKpNSU6m+WO/M/Dxqlqb5DRgTVWtAs4CzkmyHriTpkSoqruSfJCmZApYXVUXzOYHlCTNzqAF8QOaC+Tub9/vzsTDRRNU1Wqaw0O9y07teX0/cOwk236aLbf2kCTNsenuxfRfaf6DvwdYm+Sr7fsXA98ZfjxJ0qhMtwexpv18GfD5nuXfGEoaSdLYmO5mfZsvYqOdaH5K+3ZdVXllsyRtxwaag0jyfJqzmG6iufX3giTHe7M+Sdp+DTpJ/QHgiKpaB5DkKcBngWcNK5gkabQGvVBu183lAFBV3wN2HU4kSdI4GHQP4rIk/50tp52+li0T2JKk7dCgBfFHwJuBP27f/x/go0NJJEkaC9MWRPtchyur6mnAB4cfSZI0Dqadg2ifw7AuyZPmII8kaUwMeohpH5orqb8D/Gzzwqp6+VBSSZJGbtCC+IuhppAkjZ3p7sX0KJoJ6oOAq4Gz2ie/SZK2c9PNQZwNLKEph6NoLpiTJO0ApjvEtLiqDgFIchbewVWSdhjT7UE8dEM+Dy1J0o5luj2IZyT5Sfs6wB7t+wBVVb8y1HSSpJGZ7nbfO89VEEnSeBn0Zn2SpB2MBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSeo01IJIcmSSdUnWJ1neMb57knPb8UuSLOwbf1KSe5O8bZg5JUkTDa0g2gcNnUlzD6fFwHFJFvetdiJwV1UdBJwBnN43/kHgS8PKKEma3DD3IA4D1lfVDVX1ALASWNq3zlKaGwICnA8cniQASY4GbgTWDjGjJGkSwyyIA4Bbe95vaJd1rtPe6+keYL8kewJ/Brxnqm+Q5KQka5Ks2bhx4zYLLkka30nqdwNnVNW9U61UVSuqaklVLZk3b97cJJOkHcSgT5SbjduABT3v57fLutbZkGQXYC/gDuA5wDFJ/hrYG3gwyf1V9ZEh5pUk9RhmQVwKLEpyIE0RLANe07fOKuB44NvAMcBFVVXA725eIcm7gXstB0maW0MriKralORk4EJgZ+DjVbU2yWnAmqpaBZwFnJNkPXAnTYlIksbAMPcgqKrVwOq+Zaf2vL4fOHaar/HuoYSTJE1pXCepJUkjZkFIkjpZEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqZEFIkjpZEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqNNSCSHJkknVJ1idZ3jG+e5Jz2/FLkixsl784yWVJrm4/v3CYOSVJEw2tIJLsDJwJHAUsBo5LsrhvtROBu6rqIOAM4PR2+e3Ay6rqEOB44Jxh5ZQkdRvmHsRhwPqquqGqHgBWAkv71lkKnN2+Ph84PEmq6rtV9YN2+VpgjyS7DzGrJKnPMAviAODWnvcb2mWd61TVJuAeYL++dV4JXF5VP+//BklOSrImyZqNGzdus+CSpDGfpE5yMM1hpzd2jVfViqpaUlVL5s2bN7fhJGk7N8yCuA1Y0PN+frusc50kuwB7AXe07+cDnwdeV1XfH2JOSVKHYRbEpcCiJAcm2Q1YBqzqW2cVzSQ0wDHARVVVSfYGLgCWV9W3hphRkjSJoRVEO6dwMnAhcC1wXlWtTXJakpe3q50F7JdkPfAWYPOpsCcDBwGnJrmi/Xj8sLJKkibaZZhfvKpWA6v7lp3a8/p+4NiO7d4LvHeY2SRJUxvrSWpJ0uhYEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqZEFIkjpZEJKkThaEJKmTBSFJ6mRBSJI6WRCSpE4WhCSpkwUhSepkQUiSOlkQkqROFoQkqZMFIUnqNNSCSHJkknVJ1idZ3jG+e5Jz2/FLkizsGXtHu3xdkpcMM6ckaaKhFUSSnYEzgaOAxcBxSRb3rXYicFdVHQScAZzebrsYWAYcDBwJfLT9epKkOTLMPYjDgPVVdUNVPQCsBJb2rbMUOLt9fT5weJK0y1dW1c+r6kZgffv1JElzZJchfu0DgFt73m8AnjPZOlW1Kck9wH7t8ov7tj2g/xskOQk4qX17b5J12yb6jD0OuH22G+f0bZhkIrPNjtlmx2yzM8psT55sYJgFMXRVtQJYMeocSdZU1ZJR5+hittkx2+yYbXbGNdswDzHdBizoeT+/Xda5TpJdgL2AOwbcVpI0RMMsiEuBRUkOTLIbzaTzqr51VgHHt6+PAS6qqmqXL2vPcjoQWAR8Z4hZJUl9hnaIqZ1TOBm4ENgZ+HhVrU1yGrCmqlYBZwHnJFkP3ElTIrTrnQdcA2wC3lxVvxxW1m1g5Ie5pmC22THb7JhtdsYyW5p/2CVJ2ppXUkuSOlkQkqROFoQkqZMF8TAk2TfJvqPOIUnDYEHMUJInJVmZZCNwCfCdJD9uly0ccbyxl2T/JM9sP/YfdZ7pJNlz1BmkUfEsphlK8m3gQ8D5m0+9bW8keCxwSlU9d4TxJpXk6qo6ZITf/1Dg72guhtx80eN84G7gTVV1+WiSTS3JLVX1pDHIsT9bbjdzW1X96yjzDCLJnlV174gzhOY+bg/97oDv1Bj/4UvytKq6btQ5wIKYsSTXV9WimY7NhSS/P9kQ8HdVNW8u82wVILkCeGNVXdK3/LnAx6rqGSMJ1mR4y2RDwJ9X1cgOIz5SixVGX65JjgA+ClzP1r+7g2h+d18ZVbapjPr31usRfS+mEbksyUdp7kK7+WaEC2iuCP/uyFI1zgX+B9DV+o+a4yz9HtNfDgBVdXGSx4wiUI//AvwNzUWZ/UZ9GPaTTF6snwBGVqxtjqnKddSH5/4WeFFV3dS7sL07w2rgN0YRqs3w4cmGgL3nMMqULIiZex3Ncyzew9a7rZuvDB+lq4D3V9W/9A8kedEI8vT6UpILgE+xdbG+DvjyyFI1Lge+UFWX9Q8kecMI8vQa52KF8S7XXWjuBN3vNmDXOc7S7/XAW4Gfd4wdN8dZJuUhpu1Ikt8Fbq6qWzrGllTVmhHE6s1wFM2zPrYq1qpaPbpUkOSpwB1VNeF2y0n2H+Xx/vY/zV+nu1hvrKqTR5UNIMk/A/9xknK9taoWdGw2J5K8A3gVzbNoen93y4DzquqvRpjtIuCdVfXPHWM3VtWBI4g1gQUxQ+1dZ08EjmbrP3RfBM6qql+MKJq2U+NarPBQud5ZVRs7xkZarm2G36D7d3fN6FI1p8gD91fVfaPMMR0LYoaSfJZmgvBstuy+zqeZg9i3ql49omi95fUK4Int4rEvryQrquqk6dece+OcTRo2C2KGknyvqp4y07G5MOblNdmZQAGurKr5c5lnqwDjnW0v4B00/wXvT3MCwo9pSv99VXX3qLLBVvmOBh7PmOWbTJIvVdVRo87RZZyyOUk9c3cmORb4h6p6ECDJTjTXQdw10mTwrI6C2gBcnOR7owjUYyNwM80f3c2qff/4kSTaYpyznQdcBLygqn4EkORXgRPasSNGFw3Yku/5ffmOZ8T5kjxzsiHg0DmMMjHAGGfr5R7EDLVXS58OvIDmv3VoTkv7OrC8qm4cSTAgycXAB+gur7dUVf8zwecy2/XA4ZNMoI96MnOcs62rqqfOdGyujHO+JL8E/omti3+z51bVHnMc6SHjnK2XexAzVFU3JXk3zTUPW01Sj7IcWstoyuvMJHe3y/amKa9lI8q02YeAfYAJf4SBv57bKBN8iPHNdnOStwNnb57wba+qPoEtZ+aM0jjnu5bmGpLr+weSmG0A7kHMUJI/o/lju5Ktr85cBqysqveNKhtMetbGF6vq2tGlaiR5Gt1nlJhtEkn2AZbTZNt8uOtfaa67eV9VjfSw5jjnS3IMcHVVresYO7qqvjD3qR76/mObrZcFMUPtsfyD+88Iap+7vXbEt9oY2/Jq/8t8TZutdwLdbLOU5PVV9YlR55jMOOcz22AsiBlKch3wkqq6uW/5k4GvjPiY6ziXl9m2sXG6Z0+Xcc5ntsE4BzFzpwBfayc2Nx8rfBLNDcBGelUr8CDN9Q839y1/Qjs2SmabhSRXTTZEc9rrSI1zPrM9fBbEDFXVl5M8hYm3EL508+2/R+gUxre8TsFss7E/8BImnkIdYMJtGkZgnPOZ7WGyIGahPYX04lHn6DfO5WW2WftHYM+quqJ/IMk35jzNROOcz2wPk3MQkqROo74dryRpTFkQkqROFoR2WEnmJ/likuuT3JDkI0l2H2C7zucsJzlt84OZkpyS5NGTrPfSJN9NcmWSa5K8sV1+dJLFA3z/gdaTHi4LQjukJAE+R/MkuUXAImAPHsatNarq1Kr63+3bU4AJBZFkV2AF8LL2Ody/BXyjHT4aGOQP/6DrSQ+Lk9TaISU5HHhXVT2vZ9mv0FwLsQA4Bliy+YltSf6R5nGu32j3IP6e5k6lPwKWVdXGJJ+kOTvlicD7gXXA7VX1gp7vsS9wHfDkqvp/Pct/u932nvbjlcALgZOA3YD1wB/Q3Omzfz2AM4F5wH3AH1bVddvkF6UdmnsQ2lEdDGz1mMyq+glwE831D1N5DLCmqg6muSPnu/q+zoeBH9DcovsFfWN30tyn6OYkn03y2iQ7tY+eXAX8aVUdWlXfBz5XVc9u9zSuBU6cZL0VNI/9fBbwNuCjM/5tSB28DkKauQeBc9vXn6Y5VDWwqnpDkkOAF9H8QX8xzd1P+/1mkvfS3JF3T+DC/hWS7An8NvA/m6NmAEw7jyINwoLQjuoamsNID2kPMf0qzaGh32TrPexHTfG1ZnyctqquBq5Ocg5wI90F8Ung6Kq6MskJwPM71tkJuLuqDp1pBmk6HmLSjuprwKOTvA4gyc40D1v6SDs3cBNwaJKdkiygucp6s53YUi6vAf5vx9f/KfDY/oVJ9kzy/J5Fh7LlHlD92zwW+GE7sf3arq/dHha7sX3KIWk8Y6ofXBqUBaEdUjVnZ7wCOKa9B9MdwINV9Z/bVb5F85/9NcCHgct7Nv8ZcFiSf6GZSD6t41usAL6c5Ot9ywO8Pcm6JFcA72HL3sNK4E/bU2B/HfgL4JI2S++kc/96rwVOTHIlsJbm2QzSw+ZZTBIPnUX0WeAVVXX5dOtLOwILQpLUyUNMkqROFoQkqZMFIUnqZEFIkjpZEJKkThaEJKnT/weRuZs3hsDuNQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 3  # 设置量子比特数\n",
    "   \n",
    "# 初始化量子电路\n",
    "cir = UAnsatz(N)\n",
    "\n",
    "# 给每一个量子比特施加哈达玛门 H\n",
    "cir.superposition_layer()\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir.run_state_vector()\n",
    "\n",
    "# 获取概率分布的理论值，令 shots = 0\n",
    "res = cir.measure(shots = 0, plot = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:12.698149Z",
     "start_time": "2021-03-09T03:53:12.187946Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 3  # 设置量子比特数\n",
    "    \n",
    "# 初始化量子电路\n",
    "cir = UAnsatz(N)\n",
    "\n",
    "# 给每一个量子比特施加 Ry(pi/4)旋转\n",
    "cir.weak_superposition_layer()\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir.run_state_vector()\n",
    "\n",
    "# 获取概率分布的理论值，令 shots = 0\n",
    "res = cir.measure(shots = 0, plot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以下是一个使用频率较高的电路模板 `complex_entangled_layer(theta, DEPTH)`，用户可按照电路深度参数 `DEPTH` 快速拓展电路。其中涉及的广义旋转门 $U_3$ 的定义为\n",
    "\n",
    "$$\n",
    "U_3(\\theta, \\phi, \\varphi) := \n",
    "\\begin{bmatrix} \n",
    "\\cos \\frac{\\theta}{2} & -e^{i \\varphi}\\sin \\frac{\\theta}{2} \\\\ \n",
    "e^{i \\phi}\\sin \\frac{\\theta}{2} &e^{i (\\phi+\\varphi)} \\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}.\n",
    "\\tag{19}\n",
    "$$\n",
    "\n",
    "$U_3$ 旋转门在效果上是等价于以下组合旋转门的：\n",
    "\n",
    "$$\n",
    "U_3(\\theta, \\phi, \\varphi) \n",
    "= R_z(\\phi)*R_y(\\theta)*R_z(\\varphi)\n",
    ":=\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\phi}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\phi}{2}}\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\ \n",
    "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2} \n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\varphi}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\varphi}{2}}\n",
    "\\end{bmatrix}.\\tag{20}\n",
    "$$\n",
    "\n",
    "感兴趣的读者不妨自行验证一下。\n",
    "\n",
    "<img src=\"figures/intro-fig-complex_entangled_layer2-cn.png\" width=\"850\" >\n",
    "\n",
    "特别地，当我们处理的任务不涉及虚数时，使用电路模板 `real_entangled_layer(theta, DEPTH)` 会更加高效（$R_y$ 旋转门替代 $U_3$）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:14.040033Z",
     "start_time": "2021-03-09T03:53:13.566616Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 4            # 设置量子比特数\n",
    "DEPTH = 6        # 设置量子电路深度\n",
    "theta = np.random.randn(DEPTH, N, 3)\n",
    "    \n",
    "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "theta = paddle.to_tensor(theta)\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = UAnsatz(N)\n",
    "\n",
    "# 添加深度为 D = 6 的复数强纠缠结构QNN {Rz+Ry+Rz/U3 + CNOT's}\n",
    "cir.complex_entangled_layer(theta, DEPTH)\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir.run_state_vector()\n",
    "\n",
    "# 测量输出态的[0，1，2]号量子比特2048次，统计测量结果的频率\n",
    "res = cir.measure(shots = 2048, which_qubits = [0, 1, 2], plot = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Mode\"> 量桨的运行模式说明</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"vec\"> 波函数向量模式 </a>\n",
    "\n",
    "所谓的波函数模式也就是用复数向量表示和储存量子态。向量模式只能处理纯态，但这种模式在家用电脑硬件高效支持 **20+ 量子比特**的运算。用户可以测试下自己电脑的极限在哪里。在这种表示下，量子门（酉矩阵）作用在量子比特（一个复向量表示其所处状态）上本质上的运算是**矩阵乘以向量**：\n",
    "\n",
    "$$\n",
    "\\lvert {\\psi}\\rangle = U \\lvert {\\psi_0}\\rangle. \n",
    "\\tag{21}\n",
    "$$\n",
    "\n",
    "代码中，具体体现在 UAnsatz的调用 `cir.run_state_vector(input_state = None)`。如果我们不输入任何初始量子态，就会默认所有的量子比特都处于 $\\lvert {0}\\rangle$ 态。接着来看个具体的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:27.327236Z",
     "start_time": "2021-03-09T03:53:15.824502Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 9.65721758e-05+0.j -4.38538841e-04+0.j  2.68195580e-05+0.j ...\n",
      "  -4.32163794e-04+0.j -6.48040560e-05+0.j  1.52848347e-04+0.j]]\n"
     ]
    }
   ],
   "source": [
    "from paddle_quantum.state import vec, vec_random\n",
    "\n",
    "N = 20           # 设置量子比特数\n",
    "DEPTH = 6        # 设置量子电路深度\n",
    "theta = np.random.randn(DEPTH, N, 1)\n",
    "\n",
    "# 调用内置的 |00..0> 初始态\n",
    "initial_state1 = vec(0, N)\n",
    "# 调用内置的随机量子态 |psi>\n",
    "initial_state2 = vec_random(N)\n",
    "    \n",
    "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "theta = paddle.to_tensor(theta)\n",
    "initial_state = paddle.to_tensor(initial_state1)\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = UAnsatz(N)\n",
    "\n",
    "# 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n",
    "cir.real_entangled_layer(theta, DEPTH)\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "final_state = cir.run_state_vector(initial_state)\n",
    "print(final_state.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"density\"> 密度矩阵模式 </a>\n",
    "\n",
    "同时 Paddle quantum也支持了密度矩阵运算模式，也就是用一个密度矩阵 $\\rho = \\sum_i P_i \\lvert {\\psi_i}\\rangle\\langle{\\psi_i} \\lvert$ 表示和储存量子态。该模式下可以根据算法需要支持**混合态模拟**。但是在密度矩阵模式下，家用电脑硬件只能运行10个左右的量子比特。请用户注意这方面的限制，我们也在不断优化这个模式下的模拟器性能。在这种表示下，量子门 (酉矩阵)作用在量子态(一个迹为1的厄尔米特矩阵)上本质上的运算是**矩阵乘法**：\n",
    "\n",
    "$$\n",
    "\\rho = U \\rho_0 U^\\dagger. \n",
    "\\tag{22}\n",
    "$$\n",
    "\n",
    "代码中，具体体现在 UAnsatz的调用 `cir.run_density_matrix()`。接着来看个具体的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:27.433188Z",
     "start_time": "2021-03-09T03:53:27.333861Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.56503575+0.j  0.44320439+0.j -0.13063786+0.j  0.17964958+0.j]\n",
      " [ 0.44320439+0.j  0.34764194+0.j -0.10247011+0.j  0.14091406+0.j]\n",
      " [-0.13063786+0.j -0.10247011+0.j  0.03020384+0.j -0.04153549+0.j]\n",
      " [ 0.17964958+0.j  0.14091406+0.j -0.04153549+0.j  0.05711846+0.j]]\n"
     ]
    }
   ],
   "source": [
    "from paddle_quantum.state import density_op, density_op_random, completely_mixed_computational\n",
    "\n",
    "N = 2            # 设置量子比特数\n",
    "DEPTH = 6        # 设置量子电路深度\n",
    "theta = np.random.randn(DEPTH, N, 1)\n",
    "\n",
    "# 调用内置的 |00..0><00..0| 初始态\n",
    "initial_state1 = density_op(N)\n",
    "# 调用内置的随机量子态, 可以指定是否允许复数元素和矩阵秩 \n",
    "initial_state2 = density_op_random(N, real_or_complex=2, rank=4)\n",
    "# 调用内置的计算基下的完全混合态 \n",
    "initial_state3 = completely_mixed_computational(N)\n",
    "    \n",
    "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n",
    "theta = paddle.to_tensor(theta)\n",
    "initial_state = paddle.to_tensor(initial_state1)\n",
    "\n",
    "# 初始化量子电路\n",
    "cir = UAnsatz(N)\n",
    "\n",
    "# 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n",
    "cir.real_entangled_layer(theta, DEPTH)\n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0><00..0|\n",
    "final_state = cir.run_density_matrix(initial_state)\n",
    "print(final_state.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  <a name=\"Bell\">练习：如何从计算基制备贝尔态</a>\n",
    "\n",
    "贝尔态是一种很常用的量子纠缠态，可以表示为\n",
    "\n",
    "$$\n",
    "\\lvert {\\Phi^+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(\\lvert {00}\\rangle + \\lvert {11}\\rangle\\big)\n",
    "= \\frac{1}{\\sqrt{2}} \\,\n",
    "\\begin{bmatrix}\n",
    "1 \\\\\n",
    "0 \\\\\n",
    "0 \\\\\n",
    "1\n",
    "\\end{bmatrix}.\n",
    "\\tag{23}\n",
    "$$\n",
    "\n",
    "那么我们如何用量桨来制备一个贝尔态呢？只需要如下的量子电路："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-bell2.png\" width=\"750\" >"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:27.924758Z",
     "start_time": "2021-03-09T03:53:27.452981Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEJCAYAAACZjSCSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAVy0lEQVR4nO3dfbRddX3n8fcn4VFBBUGlBAytYSxaQY3o1C5FhQ4sNeCAgoAjFYtWUmH1SZharGjXoFZm6hAd41PRLon4nCrCOCqdUUdNQB4MGEkRJCg2yKMygpHv/HF24HC592Qnuftc793v11pn5eyHs8/37rVyP3f/fr/926kqJEn9NW+mC5AkzSyDQJJ6ziCQpJ4zCCSp5wwCSeo5g0CSem67mS5gS+2xxx61cOHCmS5DkmaVyy677Naq2nOybbMuCBYuXMjq1atnugxJmlWS3DjVNpuGJKnnDAJJ6jmDQJJ6ziCQpJ4zCCSp5wwCSeo5g0CSes4gkKSem3U3lEnqr4VnfHGmS5hRN5zz4k6O6xWBJPVcp0GQ5PAka5OsS3LGJNtPSrIhyRXN67Vd1iNJerjOmoaSzAeWAYcB64FVSVZW1TUTdv1EVS3tqg5J0mhdXhEcDKyrquur6j5gBXBkh98nSdoKXQbB3sBNQ8vrm3UTHZ3kqiSfSrJPh/VIkiYx053F/wwsrKqnAV8Gzp9spySnJFmdZPWGDRvGWqAkzXVdBsHNwPBf+AuadQ+oqp9V1b3N4geBZ052oKpaXlWLq2rxnntO+lwFSdJW6jIIVgGLkuyXZAfgOGDl8A5J9hpaXAJc22E9kqRJdDZqqKo2JlkKXALMBz5cVWuSnA2srqqVwBuTLAE2ArcBJ3VVjyRpcp3eWVxVFwEXTVh31tD7M4Ezu6xBkjTaTHcWS5JmWK/mGnKekm7mKZE0u3lFIEk9ZxBIUs8ZBJLUcwaBJPWcQSBJPWcQSFLPGQSS1HMGgST1nEEgST1nEEhSzxkEktRzBoEk9ZxBIEk9ZxBIUs8ZBJLUcwaBJPWcQSBJPWcQSFLPGQSS1HMGgST1nEEgST1nEEhSzxkEktRzBoEk9ZxBIEk9ZxBIUs8ZBJLUcwaBJPWcQSBJPWcQSFLPbTYIkjw3ySOb9ycmOTfJE9scPMnhSdYmWZfkjBH7HZ2kkixuX7okaTq0uSJ4H3BPkgOBPwf+Ffjo5j6UZD6wDDgCOAB4ZZIDJtlvV+A04NtbULckaZq0CYKNVVXAkcB5VbUM2LXF5w4G1lXV9VV1H7CiOcZEbwPeAfyyZc2SpGnUJgjuTnIm8Crgi0nmAdu3+NzewE1Dy+ubdQ9I8gxgn6r64qgDJTklyeokqzds2NDiqyVJbbUJgmOBe4HXVNUtwALgXdv6xU2gnMuguWmkqlpeVYuravGee+65rV8tSRqy2SBofvl/GtixWXUr8NkWx74Z2GdoeUGzbpNdgacClya5AXgOsNIOY0karzajhv4Y+BTw/mbV3sDnWhx7FbAoyX5JdgCOA1Zu2lhVd1bVHlW1sKoWAt8CllTV6i37ESRJ26JN09CpwHOBuwCq6jrgcZv7UFVtBJYClwDXAhdW1ZokZydZsvUlS5Km03Yt9rm3qu5LAkCS7YBqc/Cqugi4aMK6s6bY95A2x5QkTa82VwT/kuQ/AzsnOQz4JPDP3ZYlSRqXNkFwBrABuBp4HYO/8N/cZVGSpPHZbNNQVd0PfKB5SZLmmCmDIMmFVfWKJFczSZ9AVT2t08okSWMx6orgtObfl4yjEEnSzJiyj6CqftK8fUNV3Tj8At4wnvIkSV1r01l82CTrjpjuQiRJM2NUH8GfMPjL/7eTXDW0aVfgG10XJkkaj1F9BB8HvgT8FwZDSDe5u6pu67QqSdLYjAqCqqobkpw6cUOS3Q0DSZobNndF8BLgMgbDRzO0rYDf7rAuSdKYTBkEVfWS5t/9xleOJGncRnUWP2PUB6vq8ukvR5I0bqOaht49YlsBL5zmWiRJM2BU09ALxlmIJGlmjGoaemFVfTXJf5xse1V9pruyJEnjMqpp6PnAV4GXTrKtAINAkuaAUU1Db2n+/aPxlSNJGrc2D69/bJL3JLk8yWVJ/iHJY8dRnCSpe20mnVvB4AllRwPHNO8/0WVRkqTxafPw+r2q6m1Dy29PcmxXBUmSxqvNFcH/THJcknnN6xXAJV0XJkkaj1HDR+/mwTmGTgf+qdk0D/g58BddFydJ6t6oUUO7jrMQSdLMaNNHQJLdgEXATpvWVdX/7qooSdL4bDYIkryWwYPsFwBXAM8B/i/ONSRJc0KbzuLTgGcBNzbzDz0duKPLoiRJ49MmCH5ZVb8ESLJjVX0f+HfdliVJGpc2fQTrkzwG+Bzw5SS3Azd2WZQkaXw2GwRV9bLm7d8m+RrwaODiTquSJI1N21FDzwD+gMF9Bd+oqvs6rUqSNDZtJp07CzgfeCywB/CRJG9uc/AkhydZm2RdkjMm2f76JFcnuSLJ15McsKU/gCRp27S5IjgBOHCow/gcBsNI3z7qQ0nmA8uAw4D1wKokK6vqmqHdPl5V/6PZfwlwLnD4lv4QkqSt12bU0I8ZupEM2BG4ucXnDgbWVdX1TVPSCuDI4R2q6q6hxUcyaHqSJI3RqLmG/juDX8x3AmuSfLlZPgz4Totj7w3cNLS8Hnj2JN9zKvBnwA5McZNaklOAUwD23XffFl8tSWprVNPQ6ubfy4DPDq2/dDoLqKplwLIkxwNvBl49yT7LgeUAixcv9qpBkqbRqEnnzt/0PskOwP7N4tqq+lWLY98M7DO0vIDRTUorgPe1OK4kaRq1GTV0CHAdg47f9wI/SPK8FsdeBSxKsl8TJMcBKycce9HQ4oub75EkjVGbUUPvBv6wqtYCJNkfuAB45qgPVdXGJEsZPMRmPvDhqlqT5GxgdVWtBJYmORT4FXA7kzQLSZK61SYItt8UAgBV9YMk27c5eFVdBFw0Yd1ZQ+9Pa1uoJKkbbYLgsiQf5MEnlJ3Agx3JkqRZrk0QvB44FXhjs/x/GPQVSJLmgJFB0NwdfGVVPZnBXb+SpDlm5Kihqvo1sDaJd3FJ0hzVpmloNwZ3Fn8H+MWmlVW1pLOqJElj0yYI/qbzKiRJM2bUXEM7MegofhJwNfChqto4rsIkSeMxqo/gfGAxgxA4gsGNZZKkOWZU09ABVfV7AEk+RLsZRyVJs8yoK4IHJpazSUiS5q5RVwQHJtn04JgAOzfLAaqqHtV5dZKkzo2ahnr+OAuRJM2MNo+qlCTNYQaBJPWcQSBJPWcQSFLPjbqz+G5gygfFO2pIkuaGUaOGdgVI8jbgJ8DHGAwdPQHYayzVSZI616ZpaElVvbeq7q6qu6rqfcCRXRcmSRqPNkHwiyQnJJmfZF6SExiajlqSNLu1CYLjgVcAP21eL2/WSZLmgM0+j6CqbsCmIEmaszZ7RZBk/yRfSfK9ZvlpSd7cfWmSpHFo0zT0AeBMmtlIq+oq4Lgui5IkjU+bIHhEVU18FoHTUkvSHNEmCG5N8js0N5clOYbBfQWSpDmgzcPrTwWWA09OcjPwQwY3lUmS5oCRQZBkPvCGqjo0ySOBeVV193hKkySNw8ggqKpfJ/mD5r03kUnSHNSmaei7SVYCn2TojuKq+kxnVUmSxqZNEOwE/Ax44dC6AgwCSZoD2txZ/Edbe/AkhwP/AMwHPlhV50zY/mfAaxkMR90AvKaqbtza75MkbbnNBkGSjzDJcwmq6jWb+dx8YBlwGLAeWJVkZVVdM7Tbd4HFVXVPkj8B3gkcuwX1S5K2UZumoS8Mvd8JeBnw4xafOxhYV1XXAyRZwWDOogeCoKq+NrT/t4ATWxxXkjSN2jQNfXp4OckFwNdbHHtv4Kah5fXAs0fsfzLwpRbHlSRNozZXBBMtAh43nUUkORFYDDx/iu2nAKcA7LvvvtP51ZLUe236CCY+u/gW4E0tjn0zsM/Q8oJm3cTjHwr8NfD8qrp3sgNV1XIGdzezePHiKZ+jLEnacm2ahnbdymOvAhYl2Y9BABzHhAfaJHk68H7g8Kr6t638HknSNmjzPILnNtNLkOTEJOcmeeLmPldVG4GlwCXAtcCFVbUmydlJljS7vQvYBfhkkiuaG9ckSWPUpo/gfcCBSQ4E/hz4IPBRpmjPH1ZVFwEXTVh31tD7Q7eoWknStGszDfXGqioGQz/Pq6plwNY2F0mSfsO0uSK4O8mZDMb4Py/JPGD7bsuSJI1LmyuCY4F7gZOr6hYGo3/e1WlVkqSxaTNq6Bbg3KHlHzHoI5AkzQFtRg09J8mqJD9Pcl+SXye5cxzFSZK616Zp6DzglcB1wM4MZgt9b5dFSZLGp00QUFXrgPlV9euq+ghweLdlSZLGpc2ooXuS7ABckeSdwE9oGSCSpN98bX6hv6rZbymDR1XuAxzdZVGSpPFpM2roxiQ7A3tV1VvHUJMkaYzajBp6KXAFcHGzfJBzAknS3NGmaehvGTxt7A6AqroC2K+ziiRJY9UmCH5VVRPvG/CZAJI0R7QZNbQmyfHA/CSLgDcC3+y2LEnSuLS5IvhT4CkM5hu6ALgLOL3DmiRJY9Rm1NA9DB4l+dfdlyNJGrcpg2BzI4Oqasmo7ZKk2WHUFcG/B25i0Bz0bSBjqUiSNFajguAJwGEMJpw7HvgicEFVrRlHYZKk8Ziys7iZYO7iqno18BxgHXBpkqVjq06S1LmRncVJdgRezOCqYCHwHuCz3ZclSRqXUZ3FHwWeClwEvLWqvje2qiRJYzPqiuBEBrONnga8MXmgrzhAVdWjOq5NkjQGUwZBVfnMAUnqAX/ZS1LPGQSS1HMGgST1nEEgST1nEEhSzxkEktRzBoEk9VynQZDk8CRrk6xLcsYk25+X5PIkG5Mc02UtkqTJdRYESeYDy4AjgAOAVyY5YMJuPwJOAj7eVR2SpNHaPLN4ax0MrKuq6wGSrACOBK7ZtENV3dBsu7/DOiRJI3TZNLQ3gwfbbLK+WSdJ+g0yKzqLk5ySZHWS1Rs2bJjpciRpTukyCG4G9hlaXtCs22JVtbyqFlfV4j333HNaipMkDXQZBKuARUn2S7IDcBywssPvkyRthc6CoKo2AkuBS4BrgQurak2Ss5MsAUjyrCTrgZcD70/i85Alacy6HDVEVV3E4Alnw+vOGnq/ikGTkSRphsyKzmJJUncMAknqOYNAknrOIJCknjMIJKnnDAJJ6jmDQJJ6ziCQpJ4zCCSp5wwCSeo5g0CSes4gkKSeMwgkqecMAknqOYNAknrOIJCknjMIJKnnDAJJ6jmDQJJ6ziCQpJ4zCCSp5wwCSeo5g0CSes4gkKSeMwgkqecMAknqOYNAknrOIJCknjMIJKnnDAJJ6jmDQJJ6ziCQpJ7rNAiSHJ5kbZJ1Sc6YZPuOST7RbP92koVd1iNJerjOgiDJfGAZcARwAPDKJAdM2O1k4PaqehLwX4F3dFWPJGlyXV4RHAysq6rrq+o+YAVw5IR9jgTOb95/CnhRknRYkyRpgu06PPbewE1Dy+uBZ0+1T1VtTHIn8Fjg1uGdkpwCnNIs/jzJ2k4q7t4eTPjZximz/3prRs/fHOE53Daz+f/wE6fa0GUQTJuqWg4sn+k6tlWS1VW1eKbrmK08f9vOc7ht5ur567Jp6GZgn6HlBc26SfdJsh3waOBnHdYkSZqgyyBYBSxKsl+SHYDjgJUT9lkJvLp5fwzw1aqqDmuSJE3QWdNQ0+a/FLgEmA98uKrWJDkbWF1VK4EPAR9Lsg64jUFYzGWzvnlrhnn+tp3ncNvMyfMX/wCXpH7zzmJJ6jmDQJJ6ziCQpJ4zCCSp5wyCjiTZLsnrklyc5Krm9aUkr0+y/UzXN5slmZMjN6SZ4qihjiS5ALiDwVxK65vVCxjcN7F7VR07Q6XNCkl2n2oTcGVVLRhnPbNRkkcDZwJHAY8DCvg34PPAOVV1x4wVN8sl+VJVHTHTdUyXWTHFxCz1zKraf8K69cC3kvxgJgqaZTYANzL4xb9JNcuPm5GKZp8Lga8Ch1TVLQBJnsDgj5ELgT+cwdp+4yV5xlSbgIPGWErnDILu3Jbk5cCnq+p+gCTzgJcDt89oZbPD9cCLqupHEzckuWmS/fVwC6vqIdOUNYHwjiSvmaGaZpNVwL/w0D9GNnnMeEvplkHQneMYPF9hWZI7mnWPAb7G3L+Dejr8N2A34GFBALxzvKXMWjcm+Svg/Kr6KUCSxwMn8dCZgTW5a4HXVdV1EzfMtT9G7CPoUJLfZfDMhb2bVTcDn6+qa2euqtkjyZN5+Plb6flrJ8luwBkMzuGm5rSfMpjj65yq8sp0hCTHAFdX1cOmvU9yVFV9bvxVdcNRQx1J8ibg4wzatb/dvAAumOyxnXqo5i/ZFQwuy7/TvILnr7Wqur2q3lRVT66q3ZvX71bVmxh0IGuEqvrUZCHQ2G2sxXTMK4KONB3CT6mqX01YvwOwpqoWzUxls4Pnr1tJflRV+850HbPVXDt/9hF0537gtxiMfBm2V7NNo3n+tlGSq6baBDx+nLXMRn06fwZBd04HvpLkOh7smNsXeBKwdKaKmkVOx/O3rR4P/AcePkotwDfHX86s05vzZxB0pKouTrI/cDAP7excVVW/nrnKZgfP37T4ArBLVV0xcUOSS8dezezTm/NnH4Ek9ZyjhiSp5wwCSeo5g0BzWpIFST6f5Lok1yc5L8mOLT738ynWn53k0Ob96UkeMcV+L0ny3SRXJrkmyeua9UclOaDF97faT5oOBoHmrCQBPgN8rrnvYBGwM9swRUVVnVVV/6tZPB14WBA004wvB15aVQcCTwcubTYfBbT5Bd92P2mb2VmsOSvJi4C3VNXzhtY9isG9CfsAxwCLq2pps+0LwN9X1aXNFcEHGMzQeQtwXFVtSPKPDEaT/Bbw98Ba4NaqesHQd+wOfB94YlX9v6H1v9989s7mdTTwQuAUYAdgHfAqBjNbTtwPYBmwJ3AP8MdV9f1pOVHqPa8INJc9BbhseEVV3QXcwOB+hFEeCayuqqcwmIHyLROO8x7gx8ALhkOg2XYbg/l8bkxyQZITksyrqm826/+yqg6qqn8FPlNVz2quHK4FTp5iv+XAn1bVM4G/AN67xWdDmoL3EUiTux/4RPP+nxg0MbVWVa9N8nvAoQx+cR/GYNbPiZ6a5O0MZqbdBbhk4g5JdgF+H/jkoLULgM32c0htGQSay65h0PzzgKZp6AkMmnSeykOvincacawtbkOtqquBq5N8DPghkwfBPwJHVdWVSU4CDplkn3nAHVV10JbWILVh05Dmsq8Aj0jynwCSzAfeDZzXtN3fAByUZF6SfRjcxbzJPB4MkeOBr09y/LuBXSeuTLJLkkOGVh3Eg3MmTfzMrsBPmg7mEyY7dtOc9cPmQUdk4MBRP7i0JQwCzVk1GAnxMuCYZs6inwH3V9XfNbt8g8Ff6tcA7wEuH/r4L4CDk3yPQYfu2ZN8xXLg4iRfm7A+wF8lWZvkCuCtPHg1sAL4y2Zo6e8Af8NgivJvMOhgZor9TgBOTnIlsIbBMwakaeGoIfVGM2rnAuBlVXX55vaX+sIgkKSes2lIknrOIJCknjMIJKnnDAJJ6jmDQJJ6ziCQpJ4zCCSp5/4/GB0NiMjhmw0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我们制备出的贝尔态是:\n",
      "[0.70710678+0.j 0.        +0.j 0.        +0.j 0.70710678+0.j]\n"
     ]
    }
   ],
   "source": [
    "# 初始化量子电路\n",
    "cir = UAnsatz(2)\n",
    "\n",
    "# 添加量子门\n",
    "cir.h(0)\n",
    "cir.cnot([0, 1])  \n",
    "\n",
    "# 制备输出态\n",
    "# 如果用户不输入初始量子态，默认初始为|00..0>\n",
    "output_state = cir.run_state_vector()\n",
    "\n",
    "# 我们测量输出态2048次，获得测量结果频率分布\n",
    "# 如果用户想获取概率分布的理论值，可以令 shots = 0\n",
    "cir.measure(shots = 2048, plot = True)\n",
    "\n",
    "print('我们制备出的贝尔态是:')\n",
    "print(output_state.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"Op\"> 飞桨 Paddlepaddle 优化器使用教程</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"GD\"> 示例: 利用飞桨的梯度下降来优化多元函数</a>\n",
    "\n",
    "\n",
    "在这一节，我们学习如何用飞桨中的优化器找到一个多元函数的极小值\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\theta_1, \\theta_2, \\theta_3)\n",
    "= (\\theta_1)^2 + (\\theta_2)^2 + (\\theta_3)^2 + 10. \n",
    "\\tag{24}\n",
    "$$\n",
    "\n",
    "可以看出，只有当 $\\theta_1 = \\theta_2 = \\theta_3 = 0$ 的时候，$\\mathcal{L}$ 取最小值 $10$。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:47.622260Z",
     "start_time": "2021-03-09T03:53:47.183431Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "损失函数的最小值是:  10.000000010745854\n"
     ]
    }
   ],
   "source": [
    "# 超参数设置\n",
    "theta_size = 3 \n",
    "ITR = 200       # 设置迭代次数\n",
    "LR = 0.5        # 设置学习速率\n",
    "SEED = 1        # 固定随机数种子\n",
    "paddle.seed(SEED)\n",
    "\n",
    "class Optimization_ex1(paddle.nn.Layer):\n",
    "    \n",
    "    def __init__(self, shape, dtype='float64'):\n",
    "        super(Optimization_ex1, self).__init__()\n",
    "        \n",
    "        # 初始化一个长度为 theta_size的可学习参数列表，并用 [-5, 5] 的均匀分布来填充初始值\n",
    "        self.theta = self.create_parameter(shape=shape, \n",
    "                                           default_initializer=paddle.nn.initializer.Uniform(low=-5., high=5.), \n",
    "                                           dtype=dtype, is_bias=False)\n",
    "\n",
    "    # 定义损失函数和前向传播机制\n",
    "    def forward(self):\n",
    "        loss = self.theta[0] ** 2 +  self.theta[1] ** 2 + self.theta[2] ** 2 + 10\n",
    "        return loss\n",
    "    \n",
    "# 记录中间优化结果\n",
    "loss_list = []\n",
    "parameter_list = []\n",
    "    \n",
    "# 定义网络维度\n",
    "myLayer = Optimization_ex1([theta_size])\n",
    "\n",
    "# 一般来说，我们利用Adam优化器来获得相对好的收敛，当然你可以改成SGD或者是RMSprop.\n",
    "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters())    \n",
    "\n",
    "# 优化循环\n",
    "for itr in range(ITR):\n",
    "\n",
    "    # 向前传播计算损失函数\n",
    "    loss = myLayer()[0]\n",
    "\n",
    "    # 反向传播优化损失函数\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "\n",
    "    # 记录学习曲线\n",
    "    loss_list.append(loss.numpy()[0])\n",
    "    parameter_list.append(myLayer.parameters()[0].numpy())\n",
    "\n",
    "print('损失函数的最小值是: ', loss_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"ex2\"> 练习: 本征值寻找</a>\n",
    "\n",
    "接下来，我们试一个更复杂的损失函数。首先我们介绍一个随机的埃尔米特矩阵 $H$，其**本征值**为矩阵 $D$ 的对角元素， \n",
    "\n",
    "$$\n",
    "D = \\begin{bmatrix} 0.2 &0 \\\\ 0 &0.8 \\end{bmatrix}. \n",
    "\\tag{25}\n",
    "$$\n",
    "\n",
    "不用担心，我们会帮你生成这个埃尔米特矩阵 $H$。\n",
    "\n",
    "然后我们初始化参数向量$\\boldsymbol{\\theta}$，构造出一个简单的线性运算 $U(\\boldsymbol{\\theta}) = R_z(\\theta_1)*R_y(\\theta_2)*R_z(\\theta_3)$：\n",
    "\n",
    "$$\n",
    "U(\\theta_1, \\theta_2, \\theta_3) = \n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta_1}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta_1}{2}}\n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "\\cos \\frac{\\theta_2}{2} &-\\sin \\frac{\\theta_2}{2} \\\\ \n",
    "\\sin \\frac{\\theta_2}{2} &\\cos \\frac{\\theta_2}{2} \n",
    "\\end{bmatrix}\n",
    "\\begin{bmatrix}\n",
    "e^{-i\\frac{\\theta_3}{2}} & 0 \\\\ \n",
    "0 & e^{i\\frac{\\theta_3}{2}}\n",
    "\\end{bmatrix}. \n",
    "\\tag{26}\n",
    "$$\n",
    "\n",
    "我们让这个矩阵（模板）乘以 $\\lvert {0}\\rangle$，得到一个新的 2 维复向量\n",
    "\n",
    "$$ \n",
    "\\lvert {\\phi}\\rangle = U(\\theta_1, \\theta_2, \\theta_3)\\lvert {0}\\rangle. \n",
    "\\tag{27}\n",
    "$$\n",
    "\n",
    "然后，我们定义损失函数为\n",
    "\n",
    "$$\n",
    "\\mathcal{L}(\\theta_1, \\theta_2, \\theta_3) \n",
    "= \\langle{\\phi} \\lvert H \\lvert {\\phi}\\rangle \n",
    "=  \\langle{0} \\lvert  U^{\\dagger}H U \\lvert {0}\\rangle. \n",
    "\\tag{28}\n",
    "$$\n",
    "\n",
    "来看看优化后我们得到了什么！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:50.904606Z",
     "start_time": "2021-03-09T03:53:50.248060Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "随机生成的矩阵 H 是:\n",
      "[[0.65531213+0.00000000e+00j 0.00378707+2.56639434e-01j]\n",
      " [0.00378707-2.56639434e-01j 0.34468787+1.21430643e-17j]] \n",
      "\n",
      "不出所料，H 的本征值是:\n",
      "[0.2 0.8]\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import unitary_group\n",
    "\n",
    "# V 是一个 2x2 的随机酉矩阵\n",
    "V = unitary_group.rvs(2)\n",
    "\n",
    "# D 的对角元是H的本征值\n",
    "# 你可以任意改变这里的对角元数值\n",
    "D = np.diag([0.2, 0.8])\n",
    "\n",
    "# V_dagger 是 V 的埃尔米特转置\n",
    "V_dagger = V.conj().T\n",
    "\n",
    "# @：代表矩阵乘积运算\n",
    "H = (V @ D @ V_dagger)\n",
    "print('随机生成的矩阵 H 是:')\n",
    "print(H, '\\n')\n",
    "print('不出所料，H 的本征值是:')\n",
    "print(np.linalg.eigh(H)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:50.916504Z",
     "start_time": "2021-03-09T03:53:50.908516Z"
    }
   },
   "outputs": [],
   "source": [
    "# 超参数设置\n",
    "theta_size = 3    # 设置 theta 维度\n",
    "num_qubits = 1    # 设置量子比特数\n",
    "ITR = 50          # 设置迭代次数\n",
    "LR = 0.5          # 设置学习速率\n",
    "SEED = 1          # 固定theta参数的随机数种子\n",
    "paddle.seed(SEED)\n",
    "\n",
    "# 单独设置电路模块\n",
    "def U_theta(theta):\n",
    "    \n",
    "    # 初始化电路然后添加量子门\n",
    "    cir = UAnsatz(num_qubits)\n",
    "    cir.rz(theta[0], 0)\n",
    "    cir.ry(theta[1], 0)\n",
    "    cir.rz(theta[2], 0)\n",
    "    \n",
    "    # 返回参数化矩阵\n",
    "    return cir.U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:54.556150Z",
     "start_time": "2021-03-09T03:53:54.489747Z"
    }
   },
   "outputs": [],
   "source": [
    "class Optimization_ex2(paddle.nn.Layer):\n",
    "    \n",
    "    def __init__(self, shape, dtype='float64'):\n",
    "        super(Optimization_ex2, self).__init__()\n",
    "        \n",
    "        # 初始化一个长度为 theta_size的可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n",
    "        self.theta = self.create_parameter(shape=shape, \n",
    "                                           default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n",
    "                                           dtype=dtype, is_bias=False)\n",
    "        self.H = paddle.to_tensor(H)\n",
    "        \n",
    "    # 定义损失函数和前向传播机制\n",
    "    def forward(self):\n",
    "        \n",
    "        # 获取量子神经网络的酉矩阵表示\n",
    "        U = U_theta(self.theta)\n",
    "        \n",
    "        # 埃尔米特转置运算\n",
    "        U_dagger = dagger(U)\n",
    "        \n",
    "        # 计算损失函数函数\n",
    "        loss = paddle.real(matmul(U_dagger, matmul(self.H, U)))[0][0]\n",
    "        \n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:53:59.114893Z",
     "start_time": "2021-03-09T03:53:58.381044Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0   loss: 0.2878\n",
      "iter: 5   loss: 0.2202\n",
      "iter: 10   loss: 0.2044\n",
      "iter: 15   loss: 0.2010\n",
      "iter: 20   loss: 0.2003\n",
      "iter: 25   loss: 0.2001\n",
      "iter: 30   loss: 0.2000\n",
      "iter: 35   loss: 0.2000\n",
      "iter: 40   loss: 0.2000\n",
      "iter: 45   loss: 0.2000\n",
      "损失函数的最小值是:  0.2000001964593201\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "parameter_list = []\n",
    "    \n",
    "myLayer = Optimization_ex2([theta_size])\n",
    "\n",
    "# 这里采用 SGD 优化器\n",
    "opt = paddle.optimizer.SGD(learning_rate = LR, parameters = myLayer.parameters())    \n",
    "\n",
    "# 优化循环\n",
    "for itr in range(ITR):\n",
    "\n",
    "    # 前向传播计算损失函数\n",
    "    loss = myLayer()[0]\n",
    "\n",
    "    # 反向传播极小化损失函数\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "\n",
    "    # 记录学习曲线\n",
    "    loss_list.append(loss.numpy()[0])\n",
    "    parameter_list.append(myLayer.parameters()[0].numpy())\n",
    "    if itr % 5 == 0:\n",
    "        print('iter:', itr, '  loss: %.4f' % loss.numpy())\n",
    "\n",
    "print('损失函数的最小值是: ', loss_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以改变一下 $H$ 的本征值。如果将它对角化后的的对角矩阵改变为\n",
    "\n",
    "$$\n",
    "D = \\begin{bmatrix} 0.8 &0 \\\\ 0 &1.2 \\end{bmatrix}. \n",
    "\\tag{29}\n",
    "$$\n",
    "\n",
    "你会发现我们仍然得到了 $H$ 的最小本征值 $0.8$。你能找到背后的原因吗？还是说这背后隐藏着什么理论？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"demo\">量子机器学习案例</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"VQE\"> 变分量子本征求解器——无监督学习</a>\n",
    "\n",
    "目前阶段，大规模的可容错的量子计算机还未实现。我们目前只能造出有噪音的，中等规模量子计算系统（NISQ）。现在一个利用 NISQ 的量子设备很有前景的算法种类就是量子-经典混合算法。人们期望这套方法也许可以在某些应用中超越经典计算机的表现。变分量子本征求解器（Variational Quantum Eigensolver, VQE）就是里面的一个重要应用。它利用参数化的电路搜寻广阔的希尔伯特空间，并利用经典机器学习中的梯度下降来找到最优参数，并接近一个哈密顿量的基态（也就是找到一个埃尔米特矩阵的最小本征值）。为了确保你能理解, 我们来一起过一遍以下两量子比特 (2-qubit)的例子。\n",
    "\n",
    "假设我们想找到如下哈密顿量的基态：\n",
    "\n",
    "$$\n",
    "H = 0.4 \\, Z \\otimes I + 0.4 \\, I \\otimes Z + 0.2 \\, X \\otimes X. \n",
    "\\tag{30}\n",
    "$$\n",
    "\n",
    "给定一种常见的量子神经网络架构"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"figures/intro-fig-vqeAnsatz.png\" width=\"450\" >"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们已经学会如何建造这个电路了。如果需要复习，请转到 <a href=\"#QNN\">这里</a>。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:54:03.717323Z",
     "start_time": "2021-03-09T03:54:03.709869Z"
    }
   },
   "outputs": [],
   "source": [
    "from paddle_quantum.utils import pauli_str_to_matrix\n",
    "\n",
    "# 首先生成泡利字符串表示下的哈密顿量\n",
    "# 相当于0.4*kron(I, Z) + 0.4*kron(Z, I) + 0.2*kron(X, X)\n",
    "# 其中， X，Y, Z是泡利矩阵， I是单位矩阵\n",
    "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n",
    "\n",
    "# 超参数设置\n",
    "num_qubits = 2\n",
    "theta_size = 4\n",
    "ITR = 60\n",
    "LR = 0.4\n",
    "SEED = 999       \n",
    "\n",
    "# 把记录的关于哈密顿量的信息转化为矩阵表示\n",
    "H_matrix = pauli_str_to_matrix(H_info, num_qubits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:54:04.655091Z",
     "start_time": "2021-03-09T03:54:04.643511Z"
    }
   },
   "outputs": [],
   "source": [
    "class vqe_demo(paddle.nn.Layer):\n",
    "    \n",
    "    def __init__(self, shape, dtype='float64'):\n",
    "        super(vqe_demo, self).__init__()\n",
    "        \n",
    "        # 初始化一个长度为theta_size的可学习参数列表，并用[0, 2*pi]的均匀分布来填充初始值\n",
    "        self.theta = self.create_parameter(shape=shape, \n",
    "                                           default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n",
    "                                           dtype=dtype, is_bias=False)\n",
    "        \n",
    "    # 定义损失函数和前向传播机制\n",
    "    def forward(self):\n",
    "        \n",
    "        # 初始量子电路\n",
    "        cir = UAnsatz(num_qubits)\n",
    "        \n",
    "        # 添加量子门\n",
    "        cir.ry(self.theta[0], 0)\n",
    "        cir.ry(self.theta[1], 1)\n",
    "        cir.cnot([0, 1])\n",
    "        cir.ry(self.theta[2], 0)\n",
    "        cir.ry(self.theta[3], 1)\n",
    "        \n",
    "        # 选择用量子态的向量表示\n",
    "        cir.run_state_vector()\n",
    "        \n",
    "        # 计算当前量子态下关于观测量H_info的期望值\n",
    "        # 也就是 <psi|H|psi>\n",
    "        loss = cir.expecval(H_info)\n",
    "        \n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-09T03:54:17.622644Z",
     "start_time": "2021-03-09T03:54:08.611202Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "S9fO_sGR64LV",
    "outputId": "f1be9cac-5d5e-4944-c13d-32983628fa6c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0   loss: 0.7363\n",
      "iter: 10   loss: -0.5727\n",
      "iter: 20   loss: -0.7474\n",
      "iter: 30   loss: -0.8101\n",
      "iter: 40   loss: -0.8154\n",
      "iter: 50   loss: -0.8225\n",
      "计算得到的基态能量是:  -0.8242290080502013\n",
      "真实的基态能量为:  -0.8246211251235321\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "parameter_list = []\n",
    "\n",
    "# 定义网络维度\n",
    "vqe = vqe_demo([theta_size])\n",
    "\n",
    "# 一般来说，我们利用Adam优化器来获得相对好的收敛，当然你可以改成SGD或者是RMS prop.\n",
    "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe.parameters())    \n",
    "\n",
    "# 优化循环\n",
    "for itr in range(ITR):\n",
    "\n",
    "    # 前向传播计算损失函数\n",
    "    loss = vqe()\n",
    "\n",
    "    # 反向传播极小化损失函数\n",
    "    loss.backward()\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "\n",
    "    # 记录学习曲线\n",
    "    loss_list.append(loss.numpy()[0])\n",
    "    parameter_list.append(vqe.parameters()[0].numpy())\n",
    "    if itr % 10 == 0:\n",
    "        print('iter:', itr, '  loss: %.4f' % loss.numpy())\n",
    "\n",
    "\n",
    "print('计算得到的基态能量是: ', loss_list[-1])\n",
    "print('真实的基态能量为: ', np.linalg.eigh(H_matrix)[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"References\">参考文献</a>\n",
    "\n",
    "[1] Nielsen, M. A. & Chuang, I. L. Quantum computation and quantum information. (Cambridge university press, 2010).\n",
    "\n",
    "[2] Phillip Kaye, Laflamme, R. & Mosca, M. An Introduction to Quantum Computing. (2007).\n",
    "\n",
    "[3] Biamonte, J. et al. Quantum machine learning. [Nature 549, 195–202 (2017).](https://www.nature.com/articles/nature23474)\n",
    "\n",
    "[4] Schuld, M., Sinayskiy, I. & Petruccione, F. An introduction to quantum machine learning. [Contemp. Phys. 56, 172–185 (2015).](https://www.tandfonline.com/doi/abs/10.1080/00107514.2014.964942)\n",
    "\n",
    "[5] Benedetti, M., Lloyd, E., Sack, S. & Fiorentini, M. Parameterized quantum circuits as machine learning models. [Quantum Sci. Technol. 4, 043001 (2019).](https://iopscience.iop.org/article/10.1088/2058-9565/ab4eb5)\n",
    "\n",
    "[6] [Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. Nat. Commun. 5, 4213 (2014).](https://www.nature.com/articles/ncomms5213)\n",
    "\n",
    "[7] [McClean, J. R., Romero, J., Babbush, R. & Aspuru-Guzik, A. The theory of variational hybrid quantum-classical algorithms. New J. Phys. 18, 023023 (2016).](https://iopscience.iop.org/article/10.1088/1367-2630/18/2/023023)\n",
    "\n",
    "[8] [Kandala, A. et al. Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets. Nature 549, 242–246 (2017).](https://www.nature.com/articles/nature23879)\n",
    "\n",
    "[9] [Mitarai, K., Negoro, M., Kitagawa, M. & Fujii, K. Quantum circuit learning. Phys. Rev. A 98, 032309 (2018).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.032309)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>[回到 <a href=\"#Contents\">目录</a>]</p>\n",
    "\n",
    "<hr>"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "QSD-Paddle.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "426.667px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
